Win32 API 日本語リファレンス
ホーム › Devices.Usb › USBUSER_SEND_ONE_PACKET

USBUSER_SEND_ONE_PACKET

構造体
サイズx64: 48 バイト / x86: 48 バイトパッキング1

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

フィールド

フィールド型サイズx64x86説明
HeaderUSBUSER_REQUEST_HEADER16+0+0USBUSER要求共通ヘッダ。要求コードと結果を保持する。
PacketParametersPACKET_PARAMETERS32+16+161パケット送信のためのパラメータを保持する。

各言語での定義

#include <windows.h>

// USBUSER_REQUEST_HEADER  (x64 16 / x86 16 バイト)
#pragma pack(push, 1)
typedef struct USBUSER_REQUEST_HEADER {
    DWORD UsbUserRequest;
    USB_USER_ERROR_CODE UsbUserStatusCode;
    DWORD RequestBufferLength;
    DWORD ActualBufferLength;
} USBUSER_REQUEST_HEADER;
#pragma pack(pop)

// PACKET_PARAMETERS  (x64 32 / x86 32 バイト)
#pragma pack(push, 1)
typedef struct PACKET_PARAMETERS {
    BYTE DeviceAddress;
    BYTE EndpointAddress;
    WORD MaximumPacketSize;
    DWORD Timeout;
    DWORD Flags;
    DWORD DataLength;
    WORD HubDeviceAddress;
    WORD PortTTNumber;
    BYTE ErrorCount;
    BYTE Pad[3];
    INT UsbdStatusCode;
    BYTE Data[4];
} PACKET_PARAMETERS;
#pragma pack(pop)

// USBUSER_SEND_ONE_PACKET  (x64 48 / x86 48 バイト)
#pragma pack(push, 1)
typedef struct USBUSER_SEND_ONE_PACKET {
    USBUSER_REQUEST_HEADER Header;
    PACKET_PARAMETERS PacketParameters;
} USBUSER_SEND_ONE_PACKET;
#pragma pack(pop)
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct USBUSER_REQUEST_HEADER
{
    public uint UsbUserRequest;
    public int UsbUserStatusCode;
    public uint RequestBufferLength;
    public uint ActualBufferLength;
}

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct PACKET_PARAMETERS
{
    public byte DeviceAddress;
    public byte EndpointAddress;
    public ushort MaximumPacketSize;
    public uint Timeout;
    public uint Flags;
    public uint DataLength;
    public ushort HubDeviceAddress;
    public ushort PortTTNumber;
    public byte ErrorCount;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] public byte[] Pad;
    public int UsbdStatusCode;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Data;
}

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct USBUSER_SEND_ONE_PACKET
{
    public USBUSER_REQUEST_HEADER Header;
    public PACKET_PARAMETERS PacketParameters;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure USBUSER_REQUEST_HEADER
    Public UsbUserRequest As UInteger
    Public UsbUserStatusCode As Integer
    Public RequestBufferLength As UInteger
    Public ActualBufferLength As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure PACKET_PARAMETERS
    Public DeviceAddress As Byte
    Public EndpointAddress As Byte
    Public MaximumPacketSize As UShort
    Public Timeout As UInteger
    Public Flags As UInteger
    Public DataLength As UInteger
    Public HubDeviceAddress As UShort
    Public PortTTNumber As UShort
    Public ErrorCount As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=3)> Public Pad() As Byte
    Public UsbdStatusCode As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Public Data() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure USBUSER_SEND_ONE_PACKET
    Public Header As USBUSER_REQUEST_HEADER
    Public PacketParameters As PACKET_PARAMETERS
End Structure
import ctypes
from ctypes import wintypes

class USBUSER_REQUEST_HEADER(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("UsbUserRequest", wintypes.DWORD),
        ("UsbUserStatusCode", ctypes.c_int),
        ("RequestBufferLength", wintypes.DWORD),
        ("ActualBufferLength", wintypes.DWORD),
    ]

class PACKET_PARAMETERS(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("DeviceAddress", ctypes.c_ubyte),
        ("EndpointAddress", ctypes.c_ubyte),
        ("MaximumPacketSize", ctypes.c_ushort),
        ("Timeout", wintypes.DWORD),
        ("Flags", wintypes.DWORD),
        ("DataLength", wintypes.DWORD),
        ("HubDeviceAddress", ctypes.c_ushort),
        ("PortTTNumber", ctypes.c_ushort),
        ("ErrorCount", ctypes.c_ubyte),
        ("Pad", ctypes.c_ubyte * 3),
        ("UsbdStatusCode", ctypes.c_int),
        ("Data", ctypes.c_ubyte * 4),
    ]

class USBUSER_SEND_ONE_PACKET(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("Header", USBUSER_REQUEST_HEADER),
        ("PacketParameters", PACKET_PARAMETERS),
    ]
#[repr(C, packed(1))]
pub struct USBUSER_REQUEST_HEADER {
    pub UsbUserRequest: u32,
    pub UsbUserStatusCode: i32,
    pub RequestBufferLength: u32,
    pub ActualBufferLength: u32,
}

#[repr(C, packed(1))]
pub struct PACKET_PARAMETERS {
    pub DeviceAddress: u8,
    pub EndpointAddress: u8,
    pub MaximumPacketSize: u16,
    pub Timeout: u32,
    pub Flags: u32,
    pub DataLength: u32,
    pub HubDeviceAddress: u16,
    pub PortTTNumber: u16,
    pub ErrorCount: u8,
    pub Pad: [u8; 3],
    pub UsbdStatusCode: i32,
    pub Data: [u8; 4],
}

#[repr(C, packed(1))]
pub struct USBUSER_SEND_ONE_PACKET {
    pub Header: USBUSER_REQUEST_HEADER,
    pub PacketParameters: PACKET_PARAMETERS,
}
import "golang.org/x/sys/windows"

type USBUSER_REQUEST_HEADER struct {
	UsbUserRequest uint32
	UsbUserStatusCode int32
	RequestBufferLength uint32
	ActualBufferLength uint32
}

type PACKET_PARAMETERS struct {
	DeviceAddress byte
	EndpointAddress byte
	MaximumPacketSize uint16
	Timeout uint32
	Flags uint32
	DataLength uint32
	HubDeviceAddress uint16
	PortTTNumber uint16
	ErrorCount byte
	Pad [3]byte
	UsbdStatusCode int32
	Data [4]byte
}

type USBUSER_SEND_ONE_PACKET struct {
	Header USBUSER_REQUEST_HEADER
	PacketParameters PACKET_PARAMETERS
}
type
  USBUSER_REQUEST_HEADER = packed record
    UsbUserRequest: DWORD;
    UsbUserStatusCode: Integer;
    RequestBufferLength: DWORD;
    ActualBufferLength: DWORD;
  end;

  PACKET_PARAMETERS = packed record
    DeviceAddress: Byte;
    EndpointAddress: Byte;
    MaximumPacketSize: Word;
    Timeout: DWORD;
    Flags: DWORD;
    DataLength: DWORD;
    HubDeviceAddress: Word;
    PortTTNumber: Word;
    ErrorCount: Byte;
    Pad: array[0..2] of Byte;
    UsbdStatusCode: Integer;
    Data: array[0..3] of Byte;
  end;

  USBUSER_SEND_ONE_PACKET = packed record
    Header: USBUSER_REQUEST_HEADER;
    PacketParameters: PACKET_PARAMETERS;
  end;
const USBUSER_REQUEST_HEADER = extern struct {
    UsbUserRequest: u32,
    UsbUserStatusCode: i32,
    RequestBufferLength: u32,
    ActualBufferLength: u32,
};

const PACKET_PARAMETERS = extern struct {
    DeviceAddress: u8,
    EndpointAddress: u8,
    MaximumPacketSize: u16,
    Timeout: u32,
    Flags: u32,
    DataLength: u32,
    HubDeviceAddress: u16,
    PortTTNumber: u16,
    ErrorCount: u8,
    Pad: [3]u8,
    UsbdStatusCode: i32,
    Data: [4]u8,
};

const USBUSER_SEND_ONE_PACKET = extern struct {
    Header: USBUSER_REQUEST_HEADER,
    PacketParameters: PACKET_PARAMETERS,
};
type
  USBUSER_REQUEST_HEADER {.packed.} = object
    UsbUserRequest: uint32
    UsbUserStatusCode: int32
    RequestBufferLength: uint32
    ActualBufferLength: uint32

  PACKET_PARAMETERS {.packed.} = object
    DeviceAddress: uint8
    EndpointAddress: uint8
    MaximumPacketSize: uint16
    Timeout: uint32
    Flags: uint32
    DataLength: uint32
    HubDeviceAddress: uint16
    PortTTNumber: uint16
    ErrorCount: uint8
    Pad: array[3, uint8]
    UsbdStatusCode: int32
    Data: array[4, uint8]

  USBUSER_SEND_ONE_PACKET {.packed.} = object
    Header: USBUSER_REQUEST_HEADER
    PacketParameters: PACKET_PARAMETERS
align(1)
struct USBUSER_REQUEST_HEADER
{
    uint UsbUserRequest;
    int UsbUserStatusCode;
    uint RequestBufferLength;
    uint ActualBufferLength;
}

align(1)
struct PACKET_PARAMETERS
{
    ubyte DeviceAddress;
    ubyte EndpointAddress;
    ushort MaximumPacketSize;
    uint Timeout;
    uint Flags;
    uint DataLength;
    ushort HubDeviceAddress;
    ushort PortTTNumber;
    ubyte ErrorCount;
    ubyte[3] Pad;
    int UsbdStatusCode;
    ubyte[4] Data;
}

align(1)
struct USBUSER_SEND_ONE_PACKET
{
    USBUSER_REQUEST_HEADER Header;
    PACKET_PARAMETERS PacketParameters;
}

HSP用 定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; USBUSER_SEND_ONE_PACKET サイズ: 48 バイト(x64)
dim st, 12    ; 4byte整数×12(構造体サイズ 48 / 4 切り上げ)
; Header : USBUSER_REQUEST_HEADER (+0, 16byte)  varptr(st)+0 を基点に操作(16byte:入れ子/配列)
; PacketParameters : PACKET_PARAMETERS (+16, 32byte)  varptr(st)+16 を基点に操作(32byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global USBUSER_REQUEST_HEADER, pack=1
    #field int UsbUserRequest
    #field int UsbUserStatusCode
    #field int RequestBufferLength
    #field int ActualBufferLength
#endstruct

#defstruct global PACKET_PARAMETERS, pack=1
    #field byte DeviceAddress
    #field byte EndpointAddress
    #field short MaximumPacketSize
    #field int Timeout
    #field int Flags
    #field int DataLength
    #field short HubDeviceAddress
    #field short PortTTNumber
    #field byte ErrorCount
    #field byte Pad 3
    #field int UsbdStatusCode
    #field byte Data 4
#endstruct

#defstruct global USBUSER_SEND_ONE_PACKET, pack=1
    #field USBUSER_REQUEST_HEADER Header
    #field PACKET_PARAMETERS PacketParameters
#endstruct

stdim st, USBUSER_SEND_ONE_PACKET        ; NSTRUCT 変数を確保