Win32 API 日本語リファレンス
ホーム › System.Power › MACHINE_POWER_POLICY

MACHINE_POWER_POLICY

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 64 バイト / x86: 64 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド型サイズx64x86説明
RevisionDWORD4+0+0ポリシー構造体のリビジョン番号である。
MinSleepAcSYSTEM_POWER_STATE4+4+4AC電源時の最小スリープ状態(SYSTEM_POWER_STATE)である。
MinSleepDcSYSTEM_POWER_STATE4+8+8バッテリ時の最小スリープ状態(SYSTEM_POWER_STATE)である。
ReducedLatencySleepAcSYSTEM_POWER_STATE4+12+12AC電源時の低遅延スリープ状態である。
ReducedLatencySleepDcSYSTEM_POWER_STATE4+16+16バッテリ時の低遅延スリープ状態である。
DozeTimeoutAcDWORD4+20+20AC電源時、ドーズへ移行するまでの時間(秒)である。
DozeTimeoutDcDWORD4+24+24バッテリ時、ドーズへ移行するまでの時間(秒)である。
DozeS4TimeoutAcDWORD4+28+28AC電源時、休止状態(S4)へ移行するまでの時間(秒)である。
DozeS4TimeoutDcDWORD4+32+32バッテリ時、休止状態(S4)へ移行するまでの時間(秒)である。
MinThrottleAcBYTE1+36+36AC電源時の最小プロセッサスロットル率(パーセント)である。
MinThrottleDcBYTE1+37+37バッテリ時の最小プロセッサスロットル率(パーセント)である。
pad1BYTE2+38+38アライメント用パディングである。
OverThrottledAcPOWER_ACTION_POLICY12+40+40AC電源時に過剰スロットルとなった際の動作(POWER_ACTION_POLICY)である。
OverThrottledDcPOWER_ACTION_POLICY12+52+52バッテリ時に過剰スロットルとなった際の動作である。

各言語での定義

#include <windows.h>

// POWER_ACTION_POLICY  (x64 12 / x86 12 バイト)
typedef struct POWER_ACTION_POLICY {
    POWER_ACTION Action;
    DWORD Flags;
    POWER_ACTION_POLICY_EVENT_CODE EventCode;
} POWER_ACTION_POLICY;

// MACHINE_POWER_POLICY  (x64 64 / x86 64 バイト)
typedef struct MACHINE_POWER_POLICY {
    DWORD Revision;
    SYSTEM_POWER_STATE MinSleepAc;
    SYSTEM_POWER_STATE MinSleepDc;
    SYSTEM_POWER_STATE ReducedLatencySleepAc;
    SYSTEM_POWER_STATE ReducedLatencySleepDc;
    DWORD DozeTimeoutAc;
    DWORD DozeTimeoutDc;
    DWORD DozeS4TimeoutAc;
    DWORD DozeS4TimeoutDc;
    BYTE MinThrottleAc;
    BYTE MinThrottleDc;
    BYTE pad1[2];
    POWER_ACTION_POLICY OverThrottledAc;
    POWER_ACTION_POLICY OverThrottledDc;
} MACHINE_POWER_POLICY;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POWER_ACTION_POLICY
{
    public int Action;
    public uint Flags;
    public uint EventCode;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MACHINE_POWER_POLICY
{
    public uint Revision;
    public int MinSleepAc;
    public int MinSleepDc;
    public int ReducedLatencySleepAc;
    public int ReducedLatencySleepDc;
    public uint DozeTimeoutAc;
    public uint DozeTimeoutDc;
    public uint DozeS4TimeoutAc;
    public uint DozeS4TimeoutDc;
    public byte MinThrottleAc;
    public byte MinThrottleDc;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public byte[] pad1;
    public POWER_ACTION_POLICY OverThrottledAc;
    public POWER_ACTION_POLICY OverThrottledDc;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POWER_ACTION_POLICY
    Public Action As Integer
    Public Flags As UInteger
    Public EventCode As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MACHINE_POWER_POLICY
    Public Revision As UInteger
    Public MinSleepAc As Integer
    Public MinSleepDc As Integer
    Public ReducedLatencySleepAc As Integer
    Public ReducedLatencySleepDc As Integer
    Public DozeTimeoutAc As UInteger
    Public DozeTimeoutDc As UInteger
    Public DozeS4TimeoutAc As UInteger
    Public DozeS4TimeoutDc As UInteger
    Public MinThrottleAc As Byte
    Public MinThrottleDc As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=2)> Public pad1() As Byte
    Public OverThrottledAc As POWER_ACTION_POLICY
    Public OverThrottledDc As POWER_ACTION_POLICY
End Structure
import ctypes
from ctypes import wintypes

class POWER_ACTION_POLICY(ctypes.Structure):
    _fields_ = [
        ("Action", ctypes.c_int),
        ("Flags", wintypes.DWORD),
        ("EventCode", wintypes.DWORD),
    ]

class MACHINE_POWER_POLICY(ctypes.Structure):
    _fields_ = [
        ("Revision", wintypes.DWORD),
        ("MinSleepAc", ctypes.c_int),
        ("MinSleepDc", ctypes.c_int),
        ("ReducedLatencySleepAc", ctypes.c_int),
        ("ReducedLatencySleepDc", ctypes.c_int),
        ("DozeTimeoutAc", wintypes.DWORD),
        ("DozeTimeoutDc", wintypes.DWORD),
        ("DozeS4TimeoutAc", wintypes.DWORD),
        ("DozeS4TimeoutDc", wintypes.DWORD),
        ("MinThrottleAc", ctypes.c_ubyte),
        ("MinThrottleDc", ctypes.c_ubyte),
        ("pad1", ctypes.c_ubyte * 2),
        ("OverThrottledAc", POWER_ACTION_POLICY),
        ("OverThrottledDc", POWER_ACTION_POLICY),
    ]
#[repr(C)]
pub struct POWER_ACTION_POLICY {
    pub Action: i32,
    pub Flags: u32,
    pub EventCode: u32,
}

#[repr(C)]
pub struct MACHINE_POWER_POLICY {
    pub Revision: u32,
    pub MinSleepAc: i32,
    pub MinSleepDc: i32,
    pub ReducedLatencySleepAc: i32,
    pub ReducedLatencySleepDc: i32,
    pub DozeTimeoutAc: u32,
    pub DozeTimeoutDc: u32,
    pub DozeS4TimeoutAc: u32,
    pub DozeS4TimeoutDc: u32,
    pub MinThrottleAc: u8,
    pub MinThrottleDc: u8,
    pub pad1: [u8; 2],
    pub OverThrottledAc: POWER_ACTION_POLICY,
    pub OverThrottledDc: POWER_ACTION_POLICY,
}
import "golang.org/x/sys/windows"

type POWER_ACTION_POLICY struct {
	Action int32
	Flags uint32
	EventCode uint32
}

type MACHINE_POWER_POLICY struct {
	Revision uint32
	MinSleepAc int32
	MinSleepDc int32
	ReducedLatencySleepAc int32
	ReducedLatencySleepDc int32
	DozeTimeoutAc uint32
	DozeTimeoutDc uint32
	DozeS4TimeoutAc uint32
	DozeS4TimeoutDc uint32
	MinThrottleAc byte
	MinThrottleDc byte
	pad1 [2]byte
	OverThrottledAc POWER_ACTION_POLICY
	OverThrottledDc POWER_ACTION_POLICY
}
type
  POWER_ACTION_POLICY = record
    Action: Integer;
    Flags: DWORD;
    EventCode: DWORD;
  end;

  MACHINE_POWER_POLICY = record
    Revision: DWORD;
    MinSleepAc: Integer;
    MinSleepDc: Integer;
    ReducedLatencySleepAc: Integer;
    ReducedLatencySleepDc: Integer;
    DozeTimeoutAc: DWORD;
    DozeTimeoutDc: DWORD;
    DozeS4TimeoutAc: DWORD;
    DozeS4TimeoutDc: DWORD;
    MinThrottleAc: Byte;
    MinThrottleDc: Byte;
    pad1: array[0..1] of Byte;
    OverThrottledAc: POWER_ACTION_POLICY;
    OverThrottledDc: POWER_ACTION_POLICY;
  end;
const POWER_ACTION_POLICY = extern struct {
    Action: i32,
    Flags: u32,
    EventCode: u32,
};

const MACHINE_POWER_POLICY = extern struct {
    Revision: u32,
    MinSleepAc: i32,
    MinSleepDc: i32,
    ReducedLatencySleepAc: i32,
    ReducedLatencySleepDc: i32,
    DozeTimeoutAc: u32,
    DozeTimeoutDc: u32,
    DozeS4TimeoutAc: u32,
    DozeS4TimeoutDc: u32,
    MinThrottleAc: u8,
    MinThrottleDc: u8,
    pad1: [2]u8,
    OverThrottledAc: POWER_ACTION_POLICY,
    OverThrottledDc: POWER_ACTION_POLICY,
};
type
  POWER_ACTION_POLICY {.bycopy.} = object
    Action: int32
    Flags: uint32
    EventCode: uint32

  MACHINE_POWER_POLICY {.bycopy.} = object
    Revision: uint32
    MinSleepAc: int32
    MinSleepDc: int32
    ReducedLatencySleepAc: int32
    ReducedLatencySleepDc: int32
    DozeTimeoutAc: uint32
    DozeTimeoutDc: uint32
    DozeS4TimeoutAc: uint32
    DozeS4TimeoutDc: uint32
    MinThrottleAc: uint8
    MinThrottleDc: uint8
    pad1: array[2, uint8]
    OverThrottledAc: POWER_ACTION_POLICY
    OverThrottledDc: POWER_ACTION_POLICY
struct POWER_ACTION_POLICY
{
    int Action;
    uint Flags;
    uint EventCode;
}

struct MACHINE_POWER_POLICY
{
    uint Revision;
    int MinSleepAc;
    int MinSleepDc;
    int ReducedLatencySleepAc;
    int ReducedLatencySleepDc;
    uint DozeTimeoutAc;
    uint DozeTimeoutDc;
    uint DozeS4TimeoutAc;
    uint DozeS4TimeoutDc;
    ubyte MinThrottleAc;
    ubyte MinThrottleDc;
    ubyte[2] pad1;
    POWER_ACTION_POLICY OverThrottledAc;
    POWER_ACTION_POLICY OverThrottledDc;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; MACHINE_POWER_POLICY サイズ: 64 バイト(x64)
dim st, 16    ; 4byte整数×16(構造体サイズ 64 / 4 切り上げ)
; Revision : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; MinSleepAc : SYSTEM_POWER_STATE (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; MinSleepDc : SYSTEM_POWER_STATE (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; ReducedLatencySleepAc : SYSTEM_POWER_STATE (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; ReducedLatencySleepDc : SYSTEM_POWER_STATE (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; DozeTimeoutAc : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; DozeTimeoutDc : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; DozeS4TimeoutAc : DWORD (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; DozeS4TimeoutDc : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; MinThrottleAc : BYTE (+36, 1byte)  poke st,36,値  /  値 = peek(st,36)
; MinThrottleDc : BYTE (+37, 1byte)  poke st,37,値  /  値 = peek(st,37)
; pad1 : BYTE (+38, 2byte)  varptr(st)+38 を基点に操作(2byte:入れ子/配列)
; OverThrottledAc : POWER_ACTION_POLICY (+40, 12byte)  varptr(st)+40 を基点に操作(12byte:入れ子/配列)
; OverThrottledDc : POWER_ACTION_POLICY (+52, 12byte)  varptr(st)+52 を基点に操作(12byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global POWER_ACTION_POLICY
    #field int Action
    #field int Flags
    #field int EventCode
#endstruct

#defstruct global MACHINE_POWER_POLICY
    #field int Revision
    #field int MinSleepAc
    #field int MinSleepDc
    #field int ReducedLatencySleepAc
    #field int ReducedLatencySleepDc
    #field int DozeTimeoutAc
    #field int DozeTimeoutDc
    #field int DozeS4TimeoutAc
    #field int DozeS4TimeoutDc
    #field byte MinThrottleAc
    #field byte MinThrottleDc
    #field byte pad1 2
    #field POWER_ACTION_POLICY OverThrottledAc
    #field POWER_ACTION_POLICY OverThrottledDc
#endstruct

stdim st, MACHINE_POWER_POLICY        ; NSTRUCT 変数を確保
st->Revision = 100
mes "Revision=" + st->Revision