PowerGridForecast Classe

Definizione

Spazio dei nomi:

Windows.Devices.Power

Contiene informazioni sulla rete elettrica a cui è connesso il dispositivo. I dati devono essere usati in una previsione per lo spostamento temporale del tempo in cui si verificano i carichi di lavoro o per ridurre il consumo di energia in momenti intensi.

public ref class PowerGridForecast sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Devices.Power.PowerGridApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class PowerGridForecast final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Devices.Power.PowerGridApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class PowerGridForecast

Public NotInheritable Class PowerGridForecast

Ereditarietà

Object Platform::Object IInspectable PowerGridForecast

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisiti Windows

Famiglia di dispositivi	Windows Desktop Extension SDK (è stato introdotto in 10.0.26100.0)
API contract	Windows.Devices.Power.PowerGridApiContract (è stato introdotto in v1.0)

Esempio

using Windows.Devices.Power;

void PrintBestTimes(PowerGridForecast forecast)
{
    double bestSeverity = double.MaxValue;
    double bestLowImpactSeverity = double.MaxValue;
    DateTime bestTime = DateTime.MaxValue;
    DateTime bestLowImpactTime = DateTime.MaxValue;
    TimeSpan blockDuration = forecast.BlockDuration;
    DateTime startTime = forecast.StartTime;
    IList<PowerGridData> forecastSignals = forecast.Forecast;

    if (forecastSignals.Count == 0)
    {
        Console.WriteLine("Error encountered with getting forecast; try again later.");
        return;
    }

    foreach (PowerGridData data in forecastSignals)
    {
        if (data.Severity < bestSeverity)
        {
            bestSeverity = data.Severity;
            bestTime = startTime;
        }

        if (data.IsLowUserExperienceImpact && data.Severity < bestLowImpactSeverity)
        {
            bestLowImpactSeverity = data.Severity;
            bestLowImpactTime = startTime;
        }

        startTime = startTime + blockDuration;
    }

    if (bestLowImpactTime != DateTime.MaxValue)
    {
        DateTime endBestLowImpactTime = bestLowImpactTime + blockDuration;
        Console.WriteLine($"Lowest severity during low impact is {bestLowImpactSeverity}, which starts at {bestLowImpactTime.ToString()}, and ends at {endBestLowImpactTime}.");
    }
    else
    {
        Console.WriteLine("There's no low-user-impact time in which to do work.");
    }

    if (bestTime != DateTime.MaxValue)
    {
        DateTime endBestSeverity = bestTime + blockDuration;
        Console.WriteLine($"Lowest severity is {bestSeverity}, which starts at {bestTime.ToString()}, and ends at {endBestSeverity.ToString()}.");
    }
}

PowerGridForecast forecast = PowerGridForecast.GetForecast();
PrintBestTimes(forecast);

#include "pch.h"
#include <iostream>
#include <winrt/Windows.Foundation.Collections.h>
#include <winrt/Windows.Devices.Power.h>

using namespace winrt::Windows::Devices::Power;
using namespace winrt::Windows::Foundation::Collections;
using namespace winrt::Windows::Foundation;

void PrintFullForecast(PowerGridForecast const& forecast)
{
    IVectorView<PowerGridData> forecastSignals = forecast.Forecast();
    DateTime forecastStartTime = forecast.StartTime();
    TimeSpan forecastBlockDuration = forecast.BlockDuration();
    DateTime blockStartTime = forecastStartTime;

    // On failure the forecast will be empty.
    if (forecastSignals.Size() == 0)
    {
        std::wcout << L"Error encountered while reading the forecast; try again later." << std::endl;
        return;
    }

    // Iterate through the forecast printing all the data.
    for (auto const& block : forecastSignals)
    {
        auto severity = block.Severity();
        auto isLowImpact = block.IsLowUserExperienceImpact();

        std::wcout << L"Start time - ";
        PrintDateTime(blockStartTime, true);
        std::wcout << L" | End time - ";
        PrintDateTime(blockStartTime + forecastBlockDuration, true);
        std::wcout << L" | Intensity - " << severity << L" | IsLowImpactTime - " << (isLowImpact ? L"TRUE" : L"FALSE") << std::endl;

        blockStartTime = blockStartTime + forecastBlockDuration;
    }
}

void PrintBestTimes(PowerGridForecast const& forecast)
{
    IVectorView<PowerGridData> forecastSignals = forecast.Forecast();
    DateTime forecastStartTime = forecast.StartTime();
    TimeSpan forecastBlockDuration = forecast.BlockDuration();
    DateTime blockStartTime = forecastStartTime;

    // On failure the forecast will be empty
    if (forecastSignals.Size() == 0)
    {
        std::wcout << L"Error encountered while reading the forecast; try again later." << std::endl;
        return;
    }

    DateTime bestSeverityTimeUTC = DateTime::max();
    DateTime bestSeverityTimeInLowUserImpactTimeUTC = DateTime::max();

    // 1.0 is maximum severity the API can return.
    double bestSeverity = 1.0;
    double bestSeverityInLowUserImpactTime = 1.0;

    // Iterate through the forecast looking for the best times.
    for (auto const& block : forecastSignals)
    {
        auto severity = block.Severity();
        auto isLowImpact = block.IsLowUserExperienceImpact();

        // Check if there is lower severity
        if (severity < bestSeverity)
        {
            bestSeverity = severity;
            bestSeverityTimeUTC = blockStartTime;
        }

        // Check whether there's a lower severity that's also at a time with low user impact.
        if (isLowImpact && severity < bestSeverityInLowUserImpactTime)
        {
            bestSeverityInLowUserImpactTime = severity;
            bestSeverityTimeInLowUserImpactTimeUTC = blockStartTime;
        }

        blockStartTime = blockStartTime + forecastBlockDuration;
    }

    // Print out the best times only if they've been set.
    if (bestSeverityTimeUTC != DateTime::max())
    {
        std::wcout << L"Best time to do work is ";
        PrintDateTime(bestSeverityTimeUTC, true);
        std::wcout << L" with a severity of " << bestSeverity;
        std::wcout << L" and ends at ";
        PrintDateTime(bestSeverityTimeUTC + forecastBlockDuration, true);
        std::wcout << std::endl;
    }

    if (bestSeverityTimeInLowUserImpactTimeUTC != DateTime::max())
    {
        std::wcout << L"Best time with low user impact is ";
        PrintDateTime(bestSeverityTimeInLowUserImpactTimeUTC, true);
        std::wcout << L" with a severity of " << bestSeverityInLowUserImpactTime;
        std::wcout << L" and ends at ";
        PrintDateTime(bestSeverityTimeInLowUserImpactTimeUTC + forecastBlockDuration, true);
        std::wcout << std::endl;
    }
    else
    {
        std::wcout << "There's no low-user-impact time in which to do work." << std::endl;
    }
}

int main() 
{
    std::wcout << L"Power Grid Forecast WinRT API sample app." << std::endl;

    // Register for the forecast notification.
    auto revoker = PowerGridForecast::ForecastUpdated(winrt::auto_revoke, [&](auto, winrt::Windows::Foundation::IInspectable const&) {
        std::wcout << L"Forecast updated..." << std::endl;

        // Forecast has been updated; find the next best times.
        PowerGridForecast forecast = PowerGridForecast::GetForecast();
        PrintBestTimes(forecast);
    });

    // Print out the full forecast.
    PowerGridForecast forecast = PowerGridForecast::GetForecast();
    PrintFullForecast(forecast);

    // Wait until the user presses a key to exit.
    std::cout << "Listening to the signal: a new forecast has been created."
                    "Leave this program open to see when a new forecast is created, otherwise press any key to exit this program..." << std::endl;
    std::cin.get();

    return 0;
}

Commenti

Windows espone le previsioni delle emissioni di carbonio della rete elettrica in base alla rete elettrica a cui è connesso il dispositivo. Questi dati sono già utilizzati da Windows Update, ad esempio, per cambiare il tempo quando si verificano aggiornamenti per ridurre le emissioni di carbonio. Questa API espone queste stesse previsioni per ridurre le emissioni di carbonio di alcuni carichi di lavoro. Ad esempio, è possibile cambiare il tempo quando si verificano gli aggiornamenti delle app o dei giochi; o limitare la velocità in bit della riproduzione audio o un altro livello di fedeltà per il rendering; o abilitare una modalità di efficienza, se disponibile.

L'API di previsione della rete elettrica fornisce due segnali all'utente (per richiedere lo spostamento temporale). Un segnale contiene un valore di gravità normalizzato (compreso tra 0,0 e 1,0) di condizioni della griglia da ottimizzare per (intensità di carbonio). L'altro segnale , IsLowUserExperienceImpact, è un valore booleano che rappresenta quando Windows ritiene che l'utente sia lontano dal dispositivo. È possibile scegliere di usare un solo segnale anziché entrambi; i segnali hanno valore singolarmente e insieme.

Il cambio di tempo significa usare la stessa energia per svolgere il lavoro, ma farlo in un momento diverso in base a un segnale.

La gravità è un valore normalizzato compreso tra 0,0 e 1,0, dove 0 è considerato migliore e 1 è peggiore. Corrisponde alla gravità del carbonio della rete elettrica in base alla posizione in cui si trova il dispositivo.

Basso impatto sull'esperienza utente. Valore booleano che rappresenta quando Windows ritiene che l'utente sia assente o che non usi molte risorse. Questo può essere considerato come inversa orario di attività. Quando il valore è true, viene considerato un buon momento per spostare i carichi di lavoro. Quando è false, è considerato un momento non valido per spostare i carichi di lavoro in termini di esperienza utente.

Proprietà

BlockDuration	Durata di ogni elemento nel vettore Forecast .
Forecast	Ottiene un vettore che contiene i dati di previsione. La previsione è contigua e inizia in StartTime. L'ora di inizio di ogni elemento può essere calcolata con StartTime + (index * BlockDuration).
StartTime	Ottiene l'ora di inizio del primo elemento in Forecast.

Metodi

GetForecast()

Metodo statico per recuperare la previsione. In caso di errore, verrà restituita una previsione vuota.

Eventi

ForecastUpdated

Evento per notificare ai sottoscrittori quando è pronto un nuovo payload di previsione. È previsto che, quando l'app riceve questa notifica, chiamerai GetForecast.