Diventare maestri nella gestione del consumo di Windows: Una guida PowerShell per professionisti IT e MSP

Punti chiave

• Gestione automatica dei consumi: Lo script automatizza le regolazioni delle impostazioni di consumo e sospensione sui dispositivi Windows, migliorando l’efficienza degli ambienti IT.
• Opzioni di configurazione versatili: Offre parametri per lo schermo, l’ibernazione, i timeout di sospensione, i piani di consumo e le impostazioni di sospensione USB, adattabili a varie esigenze.
• Capacità di distribuzione remota: Ideale per MSP e reparti IT, consente la configurazione remota su diversi dispositivi.
• Compatibilità e limitazioni: Supporta Windows 7 e versioni successive, ma alcune impostazioni potrebbero essere soggette a limitazioni specifiche del dispositivo.
• Controllo approfondito delle impostazioni: Offre maggiore flessibilità e precisione rispetto alle regolazioni manuali tradizionali o alle policy di gruppo.
• Verifica delle impostazioni Applicazione: Include funzioni per confermare la corretta applicazione delle nuove impostazioni di consumo di Windows.
• Eseguire dei test è fondamentale: È consigliabile testare lo script in un ambiente controllato per evitare interruzioni involontarie.
• Integrazione con gli strumenti di gestione IT: Può essere efficacemente combinato con piattaforme come NinjaOne per una gestione completa delle risorse IT.

La gestione delle impostazioni di consumo dei dispositivi Windows è un aspetto cruciale della gestione IT, in quanto garantisce sia l’efficienza energetica che le prestazioni ottimali. Lo script PowerShell fornito offre ai professionisti IT una soluzione completa per regolare le impostazioni di consumo e sospensione sui sistemi basati su Windows. Questa capacità è essenziale per mantenere la salute del sistema, prolungare la durata della batteria e garantire un funzionamento efficiente dei dispositivi in vari ambienti.

Background

Nell’ambito dell’IT, in particolare per i fornitori di servizi gestiti (MSP) e i reparti IT, la possibilità di regolare in modo programmatico e remoto le impostazioni di consumo su diversi dispositivi è preziosa. Inizialmente, questo richiedeva un intervento manuale o la modifica dei criteri di gruppo, che possono essere macchinosi e dispendiosi in termini di tempo. Lo script di cui parliamo semplifica questo processo, consentendo una configurazione precisa e diversificata del consumo di un numero grande di dispositivi. La sua versatilità nella gestione di diverse impostazioni come i timeout dello schermo, dell’ibernazione e della sospensione, nonché i piani di alimentazione e le impostazioni di sospensione USB, lo rende uno strumento potente per i professionisti IT.

Lo script per le impostazioni di consumo di Windows:

<#
.SYNOPSIS
    Set Power and Sleep Settings. It can adjust just the plugged in or battery settings if requested.
    Please Note not all devices support all options.
.DESCRIPTION
    Please Note not all devices support all options.
    Options: ScreenTimeout, HibernateTimeout, SleepTimeout, Disk Timeout, PowerPlan, Lid Action, Wake Timers, USB Suspend, Critical Action
    Low Action, Power Button Action, Critical Level, Low Level, Reserve Level, Critical Notification, and Low Notification.
.EXAMPLE
    (No Parameters)
    
    By default The Script doesn't do anything without some parameters.
.LINK 
    https://learn.microsoft.com/en-us/windows/win32/power/power-policy-settings

PARAMETER: -ScreenTimeout "60"
    Replace 60 with any time in seconds to set the screen timeout. (0 for disabled)

PARAMETER: -HibernateTimeout "28800"
    Replace 28800 with any time in seconds. (0 for disabled)

PARAMETER: -SleepTimeout "14400"
    Replace 14400 with any time in seconds. (0 for disabled)

PARAMETER: -DiskTimeout "0"
    Replace 0 with your desired time in seconds. (0 for disabled)

PARAMETER: -PowerPlan "High Performance"
    Replace "High Performance" with your desired power plan. Keep in mind that most newer computers no longer have seperate power plans.

PARAMETER: -LidAction "Nothing"
    Replace Nothing with one of these three available options. Sleep, Shutdown, Nothing.
    Will be skipped for non-laptops and this script cannot verify if the action was successfully set.

PARAMETER: -AllowWakeTimers
    Allows the ability for software to wake the computer from sleep at a later date.

PARAMETER: -DisableWakeTimers
    Disables the ability for software to wake the computer from sleep at a later date.

PARAMETER: -EnableUSBSuspend
    Allows the OS to suspend USB devices to conserve power.

PARAMETER: -DisableUSBSuspend
    Disable's the OS's ability to suspend USB devices to conserve power.

PARAMETER: -CriticalAction "Hibernate"
    Replace Hibernate with your desired action for when the machine is at a "Critical" batter level.
    Valid Options: Hibernate, Sleep, Shutdown, Nothing

PARAMETER: -LowAction "Hibernate"
    Replace Hibernate with your desired action for when the machine is at a "Low" battery level.
    Valid Options: Hibernate, Sleep, Shutdown, Nothing.

PARAMETER: -CriticalLevel "7"
    Replace 7 with your desired battery percent level to be considered critical (without the % symbol).

PARAMETER: -LowLevel "10"
    Replace 10 with your desired battery percent level to be considered low (without the % symbol).

PARAMETER: -LowNotify
    Allows the notification that comes in when the battery hits "low" levels.

PARAMETER: -AC
    Only applies your chosen battery settings to the "Plugged In" section of a power plan.

PARAMETER: -DC
    Only applies your chosen battery settings to the "Battery" section of a power plan.
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2008
    General notes
    Version: Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String]$ScreenTimeout,
    [Parameter()]
    [String]$HibernateTimeout,
    [Parameter()]
    [String]$SleepTimeout,
    [Parameter()]
    [String]$DiskTimeout,
    [Parameter()]
    [String]$PowerPlan,
    [Parameter()]
    [String]$LidAction,
    [Parameter()]
    [Switch]$AllowWakeTimers,
    [Parameter()]
    [Switch]$DisableWakeTimers,
    [Parameter()]
    [Switch]$EnableUSBSuspend,
    [Parameter()]
    [Switch]$DisableUSBSuspend,
    [Parameter()]
    [String]$CriticalAction,
    [Parameter()]
    [String]$LowAction,
    [Parameter()]
    [String]$CriticalLevel,
    [Parameter()]
    [String]$LowLevel,
    [Parameter()]
    [Switch]$LowNotify,
    [Parameter()]
    [Switch]$LowNoNotify,
    [Parameter()]
    [Switch]$AC,
    [Parameter()]
    [Switch]$DC
)

begin {
    # Grab Script Variables if present
    if ($env:policy -and $env:policy -notlike "null") {
        switch ($env:policy) {
            "Plugged In" { $AC = $True }
            "On Battery" { $DC = $True }
        }
    }
    if ($env:screenTimeoutInMinutes -and $env:screenTimeoutInMinutes -notlike "null") { $ScreenTimeout = $env:screenTimeoutInMinutes }
    if ($env:hibernateTimeoutInMinutes -and $env:hibernateTimeoutInMinutes -notlike "null") { $HibernateTimeout = $env:hibernateTimeoutInMinutes }
    if ($env:sleepTimeoutInMinutes -and $env:sleepTimeoutInMinutes -notlike "null") { $SleepTimeout = $env:sleepTimeoutInMinutes }
    if ($env:diskTimeoutInMinutes -and $env:diskTimeoutInMinutes -notlike "null") { $DiskTimeout = $env:diskTimeoutInMinutes }
    if ($env:powerPlan -and $env:powerPlan -notlike "null") { $PowerPlan = $env:powerPlan }
    if ($env:lidAction -and $env:lidAction -notlike "null") { $LidAction = $env:lidAction }
    if ($env:wakeTimers -and $env:wakeTimers -notlike "null") {
        switch ($env:wakeTimers) {
            "Enable" { $AllowWakeTimers = $True }
            "Disable" { $DisableWakeTimers = $True }
        }
    }
    if ($env:usbSuspend -and $env:usbSuspend -notlike "null") {
        switch ($env:usbSuspend) {
            "Enable" { $EnableUSBSuspend = $True }
            "Disable" { $DisableUSBSuspend = $True }
        }
    }
    if ($env:criticalBatteryAction -and $env:criticalBatteryAction -notlike "null") { $CriticalAction = $env:criticalBatteryAction }
    if ($env:lowBatteryAction -and $env:lowBatteryAction -notlike "null") { $LowAction = $env:lowBatteryAction }
    if ($env:criticalBatteryLevel -and $env:criticalBatteryLevel -notlike "null") { $CriticalLevel = $env:criticalBatteryLevel }
    if ($env:lowBatteryLevel -and $env:lowBatteryLevel -notlike "null") { $LowLevel = $env:lowBatteryLevel }
    if ($env:lowNotification -and $env:lowNotification -notlike "null") {
        switch ($env:lowNotification) {
            "Enable" { $LowNotify = $True }
            "Disable" { $LowNoNotify = $True }
        }
    }

    if ($ScreenTimeout) { [int]$ScreenTimeoutValue = [int]$ScreenTimeout * 60 }
    if ($HibernateTimeout) { [int]$HibernateTimeoutValue = [int]$HibernateTimeout * 60 }
    if ($SleepTimeout) { [int]$SleepTimeoutValue = [int]$SleepTimeout * 60 }
    if ($DiskTimeout) { [int]$DiskTimeoutValue = [int]$DiskTimeout * 60 }
    if ($CriticalLevel){ [int]$CriticalLevelValue = [int]$CriticalLevel }
    if ($LowLevel){ [int]$LowLevelValue = [int]$LowLevel }

    # Elevation Test
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    if (
        -not $ScreenTimeout -and -not $HibernateTimeout -and -not $SleepTimeout -and -not $DiskTimeout -and -not $PowerPlan -and
        -not $LidAction -and -not $AllowWakeTimers -and -not $DisableWakeTimers -and -not $EnableUSBSuspend -and
        -not $DisableUSBSuspend -and -not $CriticalAction -and -not $LowAction -and -not $CriticalLevel -and
        -not $LowLevel -and -not $LowNotify -and -not $LowNoNotify
    ) {
        Write-Error -Message '[Error] No action given!'
        exit 1
    }
    
    # Check for battery and whether or not the device is a laptop
    if ($PSVersionTable.PSVersion.Major -lt 5) {
        $BatteryCheck = @(Get-WmiObject -Class Win32_Battery).Count -gt 0
        $LaptopCheck = Get-WmiObject -Class win32_systemenclosure | Where-Object { $_.chassistypes -eq 9 -or $_.chassistypes -eq 10 -or $_.chassistypes -eq 14 }
    }
    else {
        $BatteryCheck = @(Get-CimInstance -Class Win32_Battery).Count -gt 0
        $LaptopCheck = Get-CimInstance -Class win32_systemenclosure | Where-Object { $_.chassistypes -eq 9 -or $_.chassistypes -eq 10 -or $_.chassistypes -eq 14 }
    }
    
    # Function to test if policy was set correctly
    function Test-PowerValue {
        [CmdletBinding()]
        param(
            [Parameter()]
            [String]$GUID,
            [Parameter()]
            [String]$Index,
            [Parameter()]
            [int]$Value,
            [Parameter()]
            [String]$Setting
        )

        # LidAction shows no information so we'll issue a warning and then exit the test function.
        if ($GUID -eq "SUB_BUTTONS" -and $Index -eq "5ca83367-6e45-459f-a27b-476b1d01c936") {
            Write-Warning "Unable to verify LidAction via script."
            break
        }

        # Values are stored in hex so we'll need to convert it.
        $Hex = "0x" + '{0:X8}' -f $Value

        $PowerQuery = powercfg.exe /QUERY SCHEME_CURRENT $GUID | Out-String
        $RelevantSetting = $PowerQuery -split "Power Setting GUID:" | Where-Object { $_ -like "*$Index*" }
        if (-not ($RelevantSetting)) {
            Write-Warning "Unable to verify setting for $GUID $Index. This option may not exist for this machine."
            break
        }

        # Depending on how the script was ran we'll need to verify in different ways (ex. its on a laptop or only AC was specified)
        if ($AC -or -not $BatteryCheck) {
            $ACQuery = $RelevantSetting -split 's{2}' | Where-Object { $_ -eq "Current AC Power Setting Index: $Hex" }

            # Actual check code is really similar though (only difference is AC vs DC).
            if (-not $ACQuery) {
                Write-Warning "AC Value of $Hex Not Found for $GUID $Index. You may want to verify the results."
                break
            }
        }
        elseif ($DC) {
            $BatteryQuery = $RelevantSetting -split 's{2}' | Where-Object { $_ -eq "Current DC Power Setting Index: $Hex" }

            if (-not $BatteryQuery) {
                Write-Warning "DC Value of $Hex Not Found for $GUID $Index. You may want to verify the results."
                break
            }
        }
        else {
            $BatteryQuery = $RelevantSetting -split 's{2}' | Where-Object { $_ -eq "Current DC Power Setting Index: $Hex" }
            if (-not $BatteryQuery) {
                Write-Warning "DC Value of $Hex Not Found for $GUID $Index. You may want to verify the results."
                break
            }

            $ACQuery = $RelevantSetting -split 's{2}' | Where-Object { $_ -eq "Current AC Power Setting Index: $Hex" }
            if (-not $ACQuery) {
                Write-Warning "AC Value of $Hex Not Found for $GUID $Index. You may want to verify the results."
                break
            }
        }

        Write-Host "Successfully set power setting for $Setting!"
    }
    function Set-PowerAction {
        [CmdletBinding()]
        param(
            [Parameter()]
            [ValidateSet("Nothing", "Sleep", "Hibernate", "ShutDown")]
            [String]$Action,
            [Parameter()]
            [String]$GUID,
            [Parameter()]
            [String]$Index,
            [Parameter()]
            [String]$Setting
        )
        try {
            switch ($Action) {
                "Nothing" {
                    if ($AC -or -not $BatteryCheck) {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 0
                    }
                    elseif ($DC) {
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 0
                    }
                    else {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 0
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 0
                    }
    
                    Test-PowerValue $GUID $Index 0 -Setting $Setting
                }
                "Sleep" {
                    if ($AC -or -not $BatteryCheck) {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 1
                    }
                    elseif ($DC) {
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 1
                    }
                    else {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 1
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 1
                    }
    
                    Test-PowerValue $GUID $Index 1 -Setting $Setting
                }
                "Hibernate" {
                    if ($AC -or -not $BatteryCheck) {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 2
                    }
                    elseif ($DC) {
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 2
                    }
                    else {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 2
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 2
                    }
    
                    Test-PowerValue $GUID $Index 2 -Setting $Setting
                }
                "Shutdown" {
                    if ($AC -or -not $BatteryCheck) {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 3
                    }
                    elseif ($DC) {
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 3
                    }
                    else {
                        powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index 3
                        powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index 3
                    }
    
                    Test-PowerValue $GUID $Index 3 -Setting $Setting
                }
                default {
                    throw "$Action is not a valid action for $Setting, valid actions are Shutdown, Hibernate, Sleep and Nothing."
                }
            }
        }
        catch {
            Write-Warning $_.Exception.Message
            Write-Warning "Failed to set power setting for $Setting"
        }
    }

    # The actual code required to set these values is very similar.
    function Set-PowerValue {
        [CmdletBinding()]
        param(
            [Parameter()]
            [String]$Value,
            [Parameter()]
            [String]$GUID,
            [Parameter()]
            [String]$Index,
            [Parameter()]
            [String]$Setting
        )

        try {
            if ($AC -or -not $BatteryCheck) {
                powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index $Value
            }
            elseif ($DC) {
                powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index $Value
            }
            else {
                powercfg.exe /SETACVALUEINDEX SCHEME_CURRENT $GUID $Index $Value
                powercfg.exe /SETDCVALUEINDEX SCHEME_CURRENT $GUID $Index $Value
            }

            Test-PowerValue $GUID $Index $Value -Setting $Setting
        }
        catch {
            Write-Warning $_.Exception.Message
            Write-Warning "Failed to set power setting for $Setting"
        }
    }

    # Before changing the power plan we should check if it exists and whether or not it is in use.
    function Get-PowerPlan {
        [CmdletBinding()]
        param(
            [Parameter()]
            [Switch]$Active,
            [Parameter()]
            [String]$Name
        )
        if ($Active) {
            $PowerPlan = powercfg.exe /getactivescheme
            $PowerPlan = ($PowerPlan -replace "Power Scheme GUID:" -split "(?=S{8}-S{4}-S{4}-S{17})" -split '(' -replace ')') | Where-Object { $_ -ne " " }
            $PowerPlan = @(
                [PSCustomObject]@{
                    Name = $($PowerPlan | Where-Object { $_ -notmatch "S{8}-S{4}-S{4}-S{17}" })
                    GUID = $($PowerPlan | Where-Object { $_ -match "S{8}-S{4}-S{4}-S{17}" })
                }
            )
        }
        else {
            $PowerPlan = powercfg.exe /L
            $PowerPlan = $PowerPlan -replace 's{2,}', ',' -replace ' *', ',True' -replace "Existing Power Schemes (* Active)", "GUID,Name,Active" -replace "-{2,}" -replace "Power Scheme GUID: " -replace '(' -replace ')' | Where-Object { $_ } | ConvertFrom-Csv
        }

        if ($Name) {
            $PowerPlan | Where-Object { $_.Name -like $Name }
        }
        else {
            $PowerPlan
        }
    }
}
process {
    # If not elevated, exit the script.
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # If a power plan was specified, let the user know that this might not actually be a changeable option (depending on computer age).
    if ($PowerPlan) {
        Write-Warning "Devices with modern standby might only have `"Balanced`" as an option."
        Write-Warning "Link: https://learn.microsoft.com/en-us/windows/win32/power/power-policy-settings"

        $TargetPlan = Get-PowerPlan -Name $PowerPlan
        # If totally not available we're going to exit as all these settings are tied to the active power plan. 
        # If we're not able to set it we'll want to give an opportunity to correct the error.
        if ($null -eq $TargetPlan) {
            Write-Error "Your targeted Power Plan is not available."
            exit 1
        }

        if ($TargetPlan.Active -ne $True) {
            powercfg.exe /setactive $TargetPlan.GUID
        }

        $CurrentPlan = Get-PowerPlan -Active
        if ($CurrentPlan.GUID -notlike "*$($TargetPlan.GUID)*") {
            Write-Error "Failed to change power plan!"
            exit 1
        }
        else {
            Write-Host "Successfully set Power Plan!"
        }
    }

    # We're going to run through all the various options and if requested we'll adjust them.
    if ($ScreenTimeout) { Set-PowerValue -GUID "SUB_VIDEO" -Index "3c0bc021-c8a8-4e07-a973-6b14cbcb2b7e" -Value $ScreenTimeoutValue -Setting "Screen Timeout" }
    if ($HibernateTimeout) { 
        Write-Warning "Hibernate timeout is not supported by all devices and may be ignored by the System." 
        Set-PowerValue -GUID "SUB_SLEEP" -Index "9d7815a6-7ee4-497e-8888-515a05f02364" -Value $HibernateTimeoutValue -Setting "Hibernate Timeout"
    }
    if ($SleepTimeout) { Set-PowerValue -GUID "SUB_SLEEP" -Index "29f6c1db-86da-48c5-9fdb-f2b67b1f44da" -Value $SleepTimeoutValue -Setting "Sleep Timeout" }
    if ($DiskTimeout) { 
        Write-Warning "An HDD is required for this setting to display (has no effect on SSDs)."
        Set-PowerValue -GUID "SUB_DISK" -Index "6738e2c4-e8a5-4a42-b16a-e040e769756e" -Value $DiskTimeoutValue -Setting "Disk Timeout"
    }
    if ($DisableUSBSuspend) { Set-PowerValue -GUID "2a737441-1930-4402-8d77-b2bebba308a3" -Index "48e6b7a6-50f5-4782-a5d4-53bb8f07e226" -Value 0 -Setting "Disable USB Auto-Suspend" }
    if ($EnableUSBSuspend) { Set-PowerValue -GUID "2a737441-1930-4402-8d77-b2bebba308a3" -Index "48e6b7a6-50f5-4782-a5d4-53bb8f07e226" -Value 1 -Setting "Enable USB Auto-Suspend" }
    if ($AllowWakeTimers) { Set-PowerValue -GUID "SUB_SLEEP" -Index "bd3b718a-0680-4d9d-8ab2-e1d2b4ac806d" -Value 1 -Setting "Allow Wake Timers" }
    if ($DisableWakeTimers) { Set-PowerValue -GUID "SUB_SLEEP" -Index "bd3b718a-0680-4d9d-8ab2-e1d2b4ac806d" -Value 0 -Setting "Disable Wake Timers" }
    # Lid Action has slightly different options than Set-PowerAction.
    if ($LidAction -and $LaptopCheck) { 
        switch ($LidAction) {
            "Nothing" { Set-PowerValue -GUID "SUB_BUTTONS" -Index "5ca83367-6e45-459f-a27b-476b1d01c936" -Value 0 -Setting "Lid Action" }
            "Sleep" { Set-PowerValue -GUID "SUB_BUTTONS" -Index "5ca83367-6e45-459f-a27b-476b1d01c936" -Value 1 -Setting "Lid Action" }
            "Shutdown" { Set-PowerValue -GUID "SUB_BUTTONS" -Index "5ca83367-6e45-459f-a27b-476b1d01c936" -Value 3 -Setting "Lid Action" }
            default {
                Write-Error "Invalid PowerButton Option. Only Sleep, Nothing and Shutdown are allowed!"
                exit 1
            }
        } 
    }
    if ($CriticalAction) { 
        Set-PowerAction -GUID "SUB_BATTERY" -Index "637ea02f-bbcb-4015-8e2c-a1c7b9c0b546" -Action $CriticalAction -Setting "Critical Battery Action"
    }
    if ($LowAction) { 
        Set-PowerAction -GUID "SUB_BATTERY" -Index "d8742dcb-3e6a-4b3c-b3fe-374623cdcf06" -Action $LowAction -Setting "Low Battery Action"
    }
    if ($CriticalLevel) { Set-PowerValue -GUID "SUB_BATTERY" -Index "9a66d8d7-4ff7-4ef9-b5a2-5a326ca2a469" -Value $CriticalLevelValue -Setting "Critical Battery Level" }
    if ($LowLevel) { Set-PowerValue -GUID "SUB_BATTERY" -Index "8183ba9a-e910-48da-8769-14ae6dc1170a" -Value $LowLevelValue -Setting "Low Battery Level" }
    if ($LowNoNotify) { Set-PowerValue -GUID "SUB_BATTERY" -Index "bcded951-187b-4d05-bccc-f7e51960c258" -Value 0 -Setting "Disable Low Battery Notification" }
    if ($LowNotify) { Set-PowerValue -GUID "SUB_BATTERY" -Index "bcded951-187b-4d05-bccc-f7e51960c258" -Value 1 -Setting "Enable Low Battery Notification" }
}
end {
    
    
    
}

 

Analisi dettagliata

Lo script funge da strumento multiuso per regolare varie impostazioni di consumo. Inizia con la definizione dei parametri, consentendo agli utenti di specificare i valori per il timeout dello schermo, l’ibernazione, il timeout della sospensione, il timeout del disco e altro ancora. Le variabili ambientali possono essere impostate per ogni parametro, garantendo flessibilità e facilità d’uso. Lo script include una serie di funzioni per controllare le capacità del sistema, verificare se la modifica di un’impostazione è riuscita e applicare le modifiche.

Ad esempio, se un amministratore IT desidera modificare l’impostazione del timeout dello schermo, può passare il parametro ScreenTimeout con il valore di timeout desiderato in secondi. Lo script converte quindi questo valore nel formato appropriato e lo applica al sistema utilizzando il comando powercfg.exe.

Questo approccio viene replicato in varie impostazioni, come l’ibernazione, il timeout della sospensione e il timeout del disco. Lo script consente inoltre di configurare i piani di alimentazione e le opzioni di sospensione USB, fondamentali per gestire il consumo energetico e le prestazioni del dispositivo.

Casi d’uso potenziali

Immagina un MSP che gestisce un complesso di computer portatili per un cliente aziendale. Devono garantire che tutti i dispositivi passino alla modalità di risparmio energetico dopo un determinato periodo di inattività, senza alcun intervento manuale. Distribuendo questo script, l’MSP può configurare da remoto il timeout della sospensione, il timeout dell’ibernazione e persino le impostazioni dell’azione del coperchio su tutti i dispositivi, garantendo l’uniformità e l’aderenza alle policy di risparmio energetico dell’azienda.

Confronti

I metodi tradizionali di gestione delle impostazioni di consumo spesso prevedono regolazioni manuali su ogni dispositivo o la distribuzione di criteri di gruppo tramite Active Directory. Pur essendo efficaci, questi metodi non hanno la precisione e la facilità di personalizzazione offerte dallo script. Con questo approccio PowerShell, i professionisti IT possono adattare le impostazioni a esigenze specifiche e applicarle in modo più dinamico a diversi gruppi di dispositivi.

Domande frequenti

• Questo script è compatibile con tutti i dispositivi Windows?
• Lo script supporta Windows 7 e versioni successive. Tuttavia, alcune impostazioni potrebbero non essere applicabili a tutti i dispositivi a causa di limitazioni hardware.

• Questo script può gestire le impostazioni di alimentazione dei dispositivi non connessi alla rete?
• Lo script richiede la connettività di rete per essere eseguito in remoto su un dispositivo. È ideale per i dispositivi all’interno di una rete aziendale o collegati tramite VPN.

• Come fa lo script per le impostazioni di consumo di Windows a garantire che le modifiche vengano applicate correttamente?
• Include funzioni per verificare se le impostazioni applicate sono state impostate correttamente, fornendo un feedback sul successo o sul fallimento dell’operazione.

Implicazioni

Nonostante questo script faciliti notevolmente la gestione del consumo, un uso improprio può portare a conseguenze indesiderate come la sospensione o l’ibernazione prematura del sistema, che potrebbe interrompere processi importanti. È essenziale testare lo script in un ambiente controllato prima della distribuzione su larga scala.

Raccomandazioni

• Esegui sempre il backup delle impostazioni di consumo correnti prima di applicare nuove configurazioni.
• Testa lo script per impostazioni di consumo di Windows su un piccolo gruppo di dispositivi prima di procedere al rollout completo.
• Aggiorna regolarmente lo script per adattarlo ai nuovi aggiornamenti e alle nuove funzioni di Windows.

Considerazioni finali

In un’epoca in cui la gestione remota e l’automazione sono fondamentali, strumenti come NinjaOne sono diventati preziosi. NinjaOne offre solide funzionalità di monitoraggio e gestione remota, a complemento di script come questo, fornendo una piattaforma per l’implementazione, il monitoraggio e la gestione delle risorse IT. L’integrazione di tali script in un framework di gestione IT più ampio come NinjaOne può migliorare l’efficienza, ridurre il carico di lavoro manuale e contribuire a una strategia di gestione IT più proattiva.