Hardware Requirements

Before installing software we often need to know if a computer meets that software's minimum hardware requirements, like the type of processor, the amount of physical memory, the screen resolution or available harddisk space (rarely a hardware issue).

There are many alternative ways to determine installed software versions, but to check hardware nothing beats WMI.

On this page, I will show several sample WMI queries to check hardware requirements.
Some ready-to-run sample scripts are available as well, including some that don't use WMI.

To find out which WMI class you need, you can search MSDN's list of WMI Classes, or you can run one of many available tools to browse WMI:

• my own WMI Code Generator (WMIGen)
• Microsoft's Scriptomatic tool
• WBEMTest.exe (native in Windows XP Professional and later)
• WMIC.exe, a command line alternative for WBEMTest.exe (also native in Windows XP Professional and later)

Alternative Tools

Instead of using WMI, you can also retrieve system information from DMI, also known as SMBIOS.
Though the information available through SMBIOS is not as extensive as the information available through WMI, it is often much faster to retrieve.
There are no native commands to read SMBIOS information, however, so you will need a third party tool like DMIDecode.exe, or you can write and compile your own program.
Use the command dmidecode to list all available information.
Use the command dmidecode -t to see what categories of information are available, then select a category and use dmidecode -t category to list available information for that category.

For programmers, the WINAPI (user32.dll) GetSystemMetrics function may be a useful tool to retrieve information, especially on monitors and input devices.
I wrote a "wrapper" for this function, GetSystemMetrics.exe, which can be used in batch files to retrieve system information.

The .NET SystemInformation class is a great help to detect all kinds of Windows GUI settings.
I wrote two "wrappers" for this class too, SystemInformation.exe for batch files, and SystemInformation.dll for COM enabled languages (e.g. KiXtart and VBScript).

Microsoft's DEVCON (DEVice manager CONsole tool) can be used in batch files to detect, remove or install devices and drivers.

Some sample scripts use DEBUG, native since MS-DOS, but not in 64-bit Windows versions.

On this page, I will provide some alternatives to WMI, all requiring DMIDecode.exe or GetSystemMetrics.exe.

Categories

• Processor (WMI)
• Processor Info Without WMI
• Physical Memory (WMI)
• Memory Info Without WMI
• Disk Space (WMI)
• Video (WMI)
• Video Info Without WMI
• Laptop or Desktop? (WMI)
• Laptop or Desktop Without WMI
• Sample Scripts
• Related Stuff

Processor

The following code lists some of the CPU properties that we may want to query before starting a software installation.
For the full list of available properties, use one of the WMI tools listed above and/or search MSDN.

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

:: List a selection of processor properties
WMIC.EXE Path Win32_Processor Get Family,Level,NumberOfCores,NumberOfLogicalProcessors,ProcessorType,Revision,Stepping /Format:value

Batch
:: List ALL processor properties
WMIC.EXE Path Win32_Processor Get * /Format:value

KiXtart

; List a selection of processor properties
Break On

$objWMIService = GetObject( "winmgmts://./root/CIMV2" )
$colItems      = $objWMIService.ExecQuery( "SELECT * FROM Win32_Processor" )

For Each $objItem In $colItems
	? "Architecture              : " + $objItem.Architecture
	? "CurrentClockSpeed         : " + $objItem.CurrentClockSpeed
	? "Description               : " + $objItem.Description
	? "DeviceID                  : " + $objItem.DeviceID
	? "ExtClock                  : " + $objItem.ExtClock
	? "Family                    : " + $objItem.Family
	? "Level                     : " + $objItem.Level
	? "Manufacturer              : " + $objItem.Manufacturer
	? "Name                      : " + $objItem.Name
	? "NumberOfCores             : " + $objItem.NumberOfCores
	? "NumberOfLogicalProcessors : " + $objItem.NumberOfLogicalProcessors
	? "OtherFamilyDescription    : " + $objItem.OtherFamilyDescription
	? "ProcessorType             : " + $objItem.ProcessorType
	? "Revision                  : " + $objItem.Revision
	? "StatusInfo                : " + $objItem.StatusInfo
	? "Stepping                  : " + $objItem.Stepping
	? "Version                   : " + $objItem.Version
	?
Next

Quit

PowerShell

# List a selection of processor properties
$colItems = get-wmiobject -class "Win32_Processor" -namespace "root/CIMV2"

foreach ( $objItem in $colItems ) {
	write-host "Architecture              : " $objItem.Architecture
	write-host "CurrentClockSpeed         : " $objItem.CurrentClockSpeed
	write-host "Description               : " $objItem.Description
	write-host "DeviceID                  : " $objItem.DeviceID
	write-host "ExtClock                  : " $objItem.ExtClock
	write-host "Family                    : " $objItem.Family
	write-host "Level                     : " $objItem.Level
	write-host "Manufacturer              : " $objItem.Manufacturer
	write-host "Name                      : " $objItem.Name
	write-host "NumberOfCores             : " $objItem.NumberOfCores
	write-host "NumberOfLogicalProcessors : " $objItem.NumberOfLogicalProcessors
	write-host "OtherFamilyDescription    : " $objItem.OtherFamilyDescription
	write-host "ProcessorType             : " $objItem.ProcessorType
	write-host "Revision                  : " $objItem.Revision
	write-host "StatusInfo                : " $objItem.StatusInfo
	write-host "Stepping                  : " $objItem.Stepping
	write-host "Version                   : " $objItem.Version
	write-host
}

PowerShell
# List ALL processor properties
$colItems = get-wmiobject -class "Win32_Processor" -namespace "root/CIMV2"

foreach ( $objItem in $colItems ) {
	foreach ( $objProperty in $objItem.Properties ) {
		write-host $objProperty.Name "=" $objProperty.Value
	}
	write-host
}

VBScript

' List a selection of processor properties
On Error Resume Next
Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems = objWMIService.ExecQuery( "SELECT * FROM Win32_Processor" )
For Each objItem In colItems
	WScript.Echo "Architecture                 : " & objItem.Architecture
	WScript.Echo "Current Clock Speed          : " & objItem.CurrentClockSpeed & " MHz"
	WScript.Echo "Description                  : " & objItem.Description
	WScript.Echo "Device ID                    : " & objItem.DeviceID
	WScript.Echo "External Clock Speed         : " & objItem.ExtClock & " MHz"
	WScript.Echo "Family                       : " & objItem.Family
	WScript.Echo "Level                        : " & objItem.Level
	WScript.Echo "Manufacturer                 : " & objItem.Manufacturer
	WScript.Echo "Name                         : " & objItem.Name
	WScript.Echo "Number Of Cores              : " & objItem.NumberOfCores
	WScript.Echo "Number Of Logical Processors : " & objItem.NumberOfLogicalProcessors
	WScript.Echo "Other Family Description     : " & objItem.OtherFamilyDescription
	WScript.Echo "Processor Type               : " & objItem.ProcessorType
	WScript.Echo "Revision                     : " & objItem.Revision
	WScript.Echo "Status Info                  : " & objItem.StatusInfo
	WScript.Echo "Stepping                     : " & objItem.Stepping
	WScript.Echo "Version                      : " & objItem.Version
	WScript.Echo
Next

The NumberOfCores and NumberOfLogicalProcessors properties are available in Windows XP Professional SP3 and later, not in Windows XP SP2 and older versions.
If in doubt, you may want to count the For Each loop's iterations.

Full details on the Win32_Processor class' properties and their possible values and meaning can be found on MSDN.

To check for a 1GHz Intel Pentium 4 or better, we would have to list all processors of ProcessorType 3 (Central Processor), with StatusInfo 3 (Enabled), Architecture 0 (x86) or 9 (x64), and a CurrentClockSpeed value of 1000 (MHz) or more and then check for several "Family values".
AMD processors will have to be tested separately...

The following sample code exits with return code 0 if all of the requirements mentioned are met for at least one processor, or 1 if not:

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

SET RC=1
FOR /F "tokens=*" %%A IN ('WMIC.EXE Path Win32_Processor WHERE "ProcessorType=3 AND StatusInfo=3 AND Architecture=0" Get Family') DO (
	REM Inner loop required for WMIC results to remove linefeeds from variable
	FOR %%B IN (%%A) DO (
		SET Family=%%B
	)
)
:: Remove the range check if Family requirement isn't that strict
IF %Family% GTR 177 (
	IF %Family% LSS 184 (
		SET RC=0
	)
)
EXIT /B %RC%

KiXtart

Break On

; Set return code to 1 (requirements not met)
$RC = 1

; Filter for the proper Architecture, ProcessorType and StatusInfo
$strQuery      = "SELECT * FROM Win32_Processor WHERE ProcessorType='3' AND StatusInfo='3' AND ( Architecture='0' OR Architecture='9' )"
$objWMIService = GetObject( "winmgmts://./root/CIMV2" )
$colItems      = $objWMIService.ExecQuery( $strQuery )

For Each $objItem In $colItems
	; Check the clock speed
	If $objItem.CurrentClockSpeed > 999
		; Is the ProcessorFamily value in the 178..183 range?
		; Remove the range check if Family requirement isn't that strict
		If $objItem.Family > 177 And objItem.Family < 184
			; If all requirements are met, set the return code to 0
			$RC = 0
		EndIf
	EndIf
Next

; Exit with the proper return code
Quit $RC

PowerShell

# Set return code to 1 (requirements not met)
$rc = 1

# Filter for the proper Architecture, ProcessorType and StatusInfo
$colItems = get-wmiobject -class "Win32_Processor" -namespace "root/CIMV2" -filter "ProcessorType=3 AND StatusInfo=3 AND ( Architecture=0 OR Architecture=9 )"
foreach ( $objItem in $colItems ) {
	# Check the clock speed
	if ( $objItem.CurrentClockSpeed -gt 999 ) {
		# Is the ProcessorFamily value in the 178..183 range?
		# Remove the range check if Family requirement isn't that strict
		if ( $objItem.Family -gt 177 ) {
			if ( $objItem.Family -lt 184 ) {
				# If all requirements are met, set the return code to 0
				$rc = 0
			}
		}
	}
}

# Exit with the proper return code
exit $rc

VBScript

' Set return code to 1 (requirements not met)
intRC = 1

' Filter for the proper Architecture, ProcessorType and StatusInfo
strQuery = "SELECT * FROM Win32_Processor WHERE ProcessorType='3' AND StatusInfo='3' AND ( Architecture='0' OR Architecture='9' )"
Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems      = objWMIService.ExecQuery( strQuery )

' Check each processor
For Each objItem In colItems
	' Check the clock speed
	If objItem.CurrentClockSpeed > 999 Then
		' Is the ProcessorFamily value in the 178..183 range?
		' Remove the range check if Family requirement isn't that strict
		If objItem.Family > 177 And objItem.Family < 184 Then
			' If all requirements are met, set the return code to 0
			intRC = 0
		End If
	End If
Next

' Exit with the proper return code
WScript.Quit intRC

Processor Info Without WMI

The command dmidecode -t processor will provide information like this:

# dmidecode 2.10
SMBIOS 2.5 present.

Handle 0x0004, DMI type 4, 40 bytes
Processor Information
        Socket Designation: AM3
        Type: Central Processor
        Family: Other
        Manufacturer: AMD
        ID: A0 0F 10 00 FF FB 8B 17
        Version: AMD Phenom(tm) II X6 1100T Processor
        Voltage: 1.5 V
        External Clock: 200 MHz
        Max Speed: 3700 MHz
        Current Speed: 3300 MHz
        Status: Populated, Enabled
        Upgrade: Other
        L1 Cache Handle: 0x0005
        L2 Cache Handle: 0x0006
        L3 Cache Handle: 0x0007
        Serial Number: To Be Filled By O.E.M.
        Asset Tag: To Be Filled By O.E.M.
        Part Number: To Be Filled By O.E.M.
        Core Count: 6
        Core Enabled: 6
        Characteristics:
                64-bit capable

Physical Memory

Without command line arguments, the following code displays the physical memory in MBs.
If a number is specified, nothing is displayed; the script will exit with return code 0 if the actual memory matches or exceeds the specified number of MBs, or 1 if it is less.

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

:: This batch file is not as accurate as its VBScript counterpart, due to its 32 bit integer limitation
:: To test for example if the memory meets or exceeds an 8 GB requirement, pass 8000 as parameter, not 8192
SETLOCAL ENABLEDELAYEDEXPANSION
SET Memory=0
FOR /F "skip=1" %%A IN ('WMIC Path Win32_PhysicalMemory Get Capacity') DO (
	REM Capicity per module in bytes
	SET Module=%%A
	REM Remove last 6 digits because batch can only handle 32 bit integers
	SET Module=!Module:~0,-6!
	REM Decrease with 5 percent as a close approximation of 1.024 * 1.024 = 1.048576
	SET /A Module = !Module! * 95 / 100
	SET /A Memory += !Module!
)
IF "%!1"=="" (
	SET Memory
) ELSE (
	SET RC=1
	IF %Memory% GTR %1 SET RC=0
	EXIT /B !RC!
)
ENDLOCAL

KiXtart

; Command line: empty to just show the amount of memory in MB,
; or $Test=nnn where nnn is a positive integer to test if the
; total amount of memory meets or exceeds that number of MB
; (return code 0 if it does, 1 if not)
; This KiXtart script is not as accurate as its VBScript counterpart,
; due to KiXtart's 32 bit integer limitation; to test for example if
; the memory meets or exceeds an 8 GB requirement, pass $test=8000 as
; parameter, not $Test=8192
Break On

$Memory = 0
$RC     = 0

$objWMIService = GetObject( "winmgmts://./root/CIMV2" )
$colItems      = $objWMIService.ExecQuery( "SELECT * FROM Win32_PhysicalMemory" )

; Sum the capacity of all memory modules
For Each $objItem In $colItems
	; Remove last 6 digits to circumvent 32 bit integer limitation
	$Module = Substr( $objItem.Capacity, 1, Len( $objItem.Capacity ) - 6 )
	$Memory = $Memory + $Module
Next

; Roughly correct for MB vs million bytes
$Memory = 95 * $Memory / 100

; If a minimum number of MB was specified, check if the actual
; amount of physical memory matches this minimum requirement;
; if no number is specified, just display the number of MBs
If $Test
	; Set return code to 1 (requirement not met)
	$RC  = 1
	; If the requirement is met, set return code to 0
	If $Memory >= $test
		$RC = 0
	EndIf
Else
	; Display the physical memory in MBs
	? $Memory
EndIf

; Exit with the appropriate return code
Quit $RC

PowerShell

param( [int]$Minimum = 0 )

$RC = 0
$Memory = 0
$colItems = Get-WMIObject -class "Win32_PhysicalMemory" -namespace "root/CIMV2"
foreach ( $objItem in $colItems ) {
	$Memory += $objItem.Capacity
}
$Memory /= ( 1024 * 1024 )
if ( $Minimum -eq 0 ) {
	Write-Host $Memory
} else {
	if ( $Memory -lt $Minimum ) { $RC = 1 }
}
exit $RC

VBScript

intMem = 0
intRC  = 0

Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems = objWMIService.ExecQuery( "SELECT * FROM Win32_PhysicalMemory" )

' Sum the capacity of all memory modules
For Each objItem In colItems
	intMem = intMem + objItem.Capacity
Next

' If a minimum number of MB was specified, check if the actual
' amount of physical memory matches this minimum requirement;
' if no number is specified, just display the number of MBs
If WScript.Arguments.Unnamed.Count = 1 Then
	' Set return code to 1 (requirement not met)
	intRC  = 1
	intReq = WScript.Arguments.Unnamed(0)
	If IsNumeric( intReq ) Then
		' If the requirement is met, set return code to 0
		If intMem >= 1024 * 1024 * intReq Then intRC = 0
	End If
Else
	' Display the physical memory in MBs
	WScript.Echo intMem / ( 1024 * 1024 )
End If

' Exit with the appropriate return code
WScript.Quit intRC

More than 3GB in Windows XP: PAE

If more than 3GB of physical memory is required (some programs, like AutoCAD, really do) and installed in Windows XP, check if PAE is enabled: if it is, the registry DWORD value PhysicalAddressExtension in HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management will be 0x1.

The following code will return this value:

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

:: RAW version, output will look like this:
:: ! REG.EXE VERSION 3.0
::
:: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management
::	PhysicalAddressExtension    REG_DWORD       0x1
SET Key=HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management
REG Query "%Key%" /v PhysicalAddressExtension

Batch
:: Enhanced version, environment variable PAE will be set to 1 (true) if PAE is enabled, or 0 (false) if not
SET PAE=0
SET Key=HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management
FOR /F "skip=4 tokens=3" %%A IN ('REG Query "%Key%" /v PhysicalAddressExtension') DO (
	IF %%A0 EQU 16 (
		SET PAE=1
	)
)

KiXtart

$Hive  = "HKEY_LOCAL_MACHINE"
$Key   = "\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management"
$Value = "PhysicalAddressExtension"

"Physical Address Extension enabled: " + ReadValue( $Hive + $Key, $Value )

PowerShell

$regpath = "HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\"
( Get-ItemProperty -Path $regpath -Name "PhysicalAddressExtension" ).PhysicalAddressExtension | Select-Object -OutVariable PAE
$ENV:PAE = $PAE

VBScript

Set wshShell = CreateObject( "WScript.Shell" )

strHive = "HKEY_LOCAL_MACHINE"
strKey = "\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\"
strValue = "PhysicalAddressExtension"

If CInt( wshShell.RegRead( strHive & strKey & strValue ) ) = 1 Then
	blnPAE = True
Else
	blnPAE = False
End If

Set wshShell = Nothing

WScript.Echo "Physical Address Extension enabled: " & blnPAE

Memory Info Without WMI

The command dmidecode -t memory will provide information like this:

# dmidecode 2.10
SMBIOS 2.5 present.

Handle 0x003B, DMI type 16, 15 bytes
Physical Memory Array
	Location: System Board Or Motherboard
	Use: System Memory
	Error Correction Type: None
	Maximum Capacity: 16 GB
	Error Information Handle: Not Provided
	Number Of Devices: 2

Handle 0x003D, DMI type 17, 27 bytes
Memory Device
	Array Handle: 0x003B
	Error Information Handle: Not Provided
	Total Width: 64 bits
	Data Width: 64 bits
	Size: 8192 MB
	Form Factor: DIMM
	Set: None
	Locator: DIMM0
	Bank Locator: BANK0
	Type: DDR
	Type Detail: Synchronous
	Speed: 1333 MHz
	Manufacturer: Manufacturer00
	Serial Number: SerNum00
	Asset Tag: AssetTagNum0
	Part Number: ModulePartNumber00

Handle 0x003F, DMI type 17, 27 bytes
Memory Device
	Array Handle: 0x003B
	Error Information Handle: Not Provided
	Total Width: Unknown
	Data Width: Unknown
	Size: No Module Installed
	Form Factor: DIMM
	Set: None
	Locator: DIMM1
	Bank Locator: BANK1
	Type: Unknown
	Type Detail: None
	Speed: Unknown
	Manufacturer: Manufacturer01
	Serial Number: SerNum01
	Asset Tag: AssetTagNum1
	Part Number: ModulePartNumber01

Disk Space

Querying free disk space may be quite simple, as the batch file demonstrates.
The other scripts below may look intimidating, but they are more usefull to test for hardware requirements. They require a command line argument specifying the required free disk space in MBs or GBs, and list the drives that meet the requirement. They return an "ErrorLevel" 0 if at least one drive meets the requirement, or 1 if not.
The VBScript version also accepts a drive letter as an optional second argument.

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

:: List ALL harddisks, and their free space and size in bytes
WMIC.EXE Path Win32_LogicalDisk WHERE "DriveType=3" Get DeviceID,FreeSpace,Size /Format:Table

KiXtart

; Commandline argument: integer number of MB or GB required free space,
;                       suffixed by "M" or "G" (or "MB" or "GB")
;                       e.g. $Required=200GB to check all harddisks for 200 GB
;                       (actually 200,000,000,000 bytes) free space or more;
;                       if no size is specified on the command line, 0 bytes
;                       will be assumed, making all drives meet the requirement
; Return code:          0 if at least 1 drive has enough free space, 1 if not

Break On

; Return code initially set to 1 ("failure"), if a drive with
; sufficient free space is found it will be set to 0 ("success")
$RC = 1

; If we don't enforce a string, the KiXtart interpreter may "choose" to change
; the value to the largest integer possible at any time, so we'll add a "Z" as
; prefix
$Required = "Z" + $Required

If $Required = "Z"
	$Required = "Z0"
EndIf

If InStr( $Required, "G" ) > 0
	$Required = SubStr( $Required, 1, InStr( $Required, "G" ) - 1 ) + "000000000"
Else
	If InStr( $Required, "M" ) > 0
		$Required = SubStr( $Required, 1, InStr( $Required, "M" ) - 1 ) + "000000"
	EndIf
EndIf

$Query      = "SELECT * FROM Win32_LogicalDisk WHERE DriveType='3'"
$WMIService = GetObject( "winmgmts://./root/CIMV2" )
$ColItems   = $WMIService.ExecQuery( $Query )

For Each $Item In $ColItems
	If Not Compare( "Z" + $Item.FreeSpace, $Required ) = -1
		? "DeviceID              : " + $Item.DeviceID
		? "Size                  : " + $Item.Size
		? "FreeSpace             : " + $Item.FreeSpace
		? "Minimum Required      : " + SubStr( $Required, 2 )
		? "Sufficient Free Space : YES"
		?
		$RC = 0
	EndIf
Next

Quit $RC


Function Compare( $Free, $Required )
	; Compare 2 really large numbers as strings to circumvent the 32 bit
	; integer limit.
	; For large integer comparison, prefix both numbers with an identical
	; non-numeric character (e.g. Z100014080, Z220062004), or the interpreter
	; MAY choose to replace them with the largest integer it supports.
	$Compare = 0
	If Not $Free = $Required
		If Len( $Free ) = Len( $Required )
			; Use .NET SortedList object to determine the largest number
			$List = CreateObject( "System.Collections.SortedList" )
			$List.Add( $Free, $Free )
			$List.Add( $Required, $Required )
			If $List.GetKey(0) = $Free
				$Compare = -1
			Else
				$Compare = 1
			EndIf
		Else
			If Len( $Free ) > Len( $Required )
				$Compare = 1
			Else
				$Compare = -1
			EndIf
		EndIf
	EndIf
EndFunction

PowerShell

# Commandline argument: integer number of MB or GB required free space,
#                       suffixed by "M" or "G" (or "MB" or "GB") e.g.
#                       200GB to check all harddisks for at least 200 GB
#                       free space; if no size is specified on the command
#                       line, 0 bytes will be assumed, making all drives
#                       meet the requirement
# Return code:          0 if at least 1 drive has enough free space, 1 if not
param( [string]$required = "0" )

if ( $required.indexof( 'G' ) -gt 0 ) {
	$required = [int64]( $required.substring( 0, $required.indexof( "G" ) ) ) * 1024
} elseif ( $required.indexof( 'M' ) -gt 0 ) {
	$required = [int64]( $required.substring( 0, $required.indexof( "M" ) ) )
} else {
	$required = [int64]$required / 1Mb
}

$rc = 1

$colItems = get-wmiobject -class "Win32_LogicalDisk" -namespace "root/CIMV2" -filter "DriveType=3"
foreach ( $objItem in $colItems ) {
	$freespaceMB = ( [int64]$objItem.FreeSpace / 1Mb )
 	$disksizeMB  = ( [int64]$objItem.Size / 1Mb )
	if ( $freespaceMB -ge $required ) {
		write-host "DeviceID  : " $objItem.DeviceID
		write-host "Size      : " $disksizeMB
		write-host "FreeSpace : " $freespaceMB
		write-host
		$rc = 0
	}
}

exit $rc

VBScript

Option Explicit

Dim intFree, intMinReq, intRC, strDrive, strQuery, objWMIService, colItems, objItem

If WScript.Arguments.Count = 1 Then
	intMinReq = CLng( WScript.Arguments(0) )
	strQuery  = "SELECT * FROM Win32_LogicalDisk WHERE DriveType='3'"
ElseIf WScript.Arguments.Count = 2 Then
	strDrive  = WScript.Arguments(0)
	intMinReq = CLng( WScript.Arguments(1) )
	strQuery  = "SELECT * FROM Win32_LogicalDisk WHERE DriveType='3' AND DeviceID='" & strDrive & "'"
Else
	WScript.Echo "Usage:    " & WScript.ScriptName & "  [ drive ]  minfree" & vbCrLf & vbCrLf _
	           & "Where:    drive    is the drive to check for free space (default: all)" & vbCrLf _
	           & "          minfree  is the minimum amount of free space required, in MB" & vbCrLf & vbCrLf _
	           & "Returns:  return code 0 if the specified drive (or if not specified: ANY drive)" & vbCrLf _
	           & "          has the required amount of free space available, 1 if not, 2 on errors"
	WScript.Quit 2
End If

Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems      = objWMIService.ExecQuery( strQuery )
intRC = 1
For Each objItem In colItems
	intFree = CLng( objItem.FreeSpace / ( 1024 * 1024 ) )
	If intFree >= intMinReq Then
		WScript.Echo objItem.DeviceID & vbTab & intFree & " MB"
		intRC = 0
	End If
Next

WScript.Quit intRC

Full details on the Win32_LogicalDisk class' properties and their possible values and meaning can be found on MSDN.

Video

Screen resolutions are hardly ever a problem these days. However, you still may want to check it for some installations.
WMI makes this a snap:

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

WMIC.EXE Path Win32_VideoController Get CurrentHorizontalResolution,CurrentNumberOfColors,CurrentVerticalResolution /Format:Table

KiXtart

Break On
$objWMIService = GetObject( "winmgmts://./root/CIMV2" )
$colItems      = $objWMIService.ExecQuery( "SELECT * FROM Win32_VideoController" )
For Each $objItem In $colItems
	? $objItem.CurrentHorizontalResolution " x " $objItem.CurrentVerticalResolution ", " $objItem.CurrentNumberOfColors " colors"
Next
Quit

PowerShell

$colItems = get-wmiobject -class "Win32_VideoController" -namespace "root/CIMV2"
foreach ( $objItem in $colItems ) {
	$horizontal = $objItem.CurrentHorizontalResolution
	$vertical   = $objItem.CurrentVerticalResolution
	$colors     = $objItem.CurrentNumberOfColors
	write-host "$horizontal x $vertical, $colors colors"
	write-host
}

VBScript

Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems = objWMIService.ExecQuery( "SELECT * FROM Win32_VideoController" )
For Each objItem In colItems
	WScript.Echo objItem.CurrentHorizontalResolution & " x " & objItem.CurrentVerticalResolution & ", " & objItem.CurrentNumberOfColors & " colors"
Next

The code above is fine to "manually" check the resolution, but for unattended installations a comparison is more useful.
The following code will display nothing unless invalid arguments are passed on the command line. It will exit with a return code 0 if the actual screen resolution meets the specified minimum requirements, or 1 if it doesn't.
Mandatory command line arguments are the minimum required horizontal and vertical resolution in pixels:

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

SETLOCAL
IF     "%~2"=="" GOTO Syntax
IF NOT "%~3"=="" GOTO Syntax

SET RC=0
FOR /F "tokens=*" %%A IN ('WMIC Path Win32_VideoController Get CurrentHorizontalResolution,CurrentVerticalResolution /Format:Value ^| FIND "="') DO (
	FOR %%B IN (%%A) DO (
		SET %%B
	)
)
IF "%CurrentHorizontalResolution%" LSS %1 SET RC=1
IF "%CurrentVerticalResolution%"   LSS %2 SET RC=1
ENDLOCAL & EXIT /B %RC%


:Syntax
ECHO Check if the screen resolution meets your minimum requirements
ECHO.
ECHO Usage:  TestVideo.kix  $$Horizontal=minH  $$Vertical=minV
ECHO Where:  minH   is the minimum required Horizontal resolution in pixels
ECHO         minV   is the minimum required Vertical resolution in pixels
ECHO.
ECHO Note:   Return code 0 if requirements are met, 1 if not, 2 on errors
EXIT /B 2

KiXtart

Break On

$Horizontal = Int( $Horizontal )
$Vertical   = Int( $Vertical )

If $Horizontal * $Vertical = 0
	? "Check if the screen resolution meets your minimum requirements@CRLF"
	? "Usage:  TestVideo.kix  $$Horizontal=minH  $$Vertical=minV@CRLF"
	? "Where:  minH   is the minimum required Horizontal resolution in pixels"
	? "        minV   is the minimum required Vertical resolution in pixels"
	? "Note:   Return code 0 if requirements are met, 1 if not, 2 on errors"
	Quit 2
EndIf
	
$RC = 0

$objWMIService = GetObject( "winmgmts://./root/CIMV2" )
$colItems      = $objWMIService.ExecQuery( "SELECT * FROM Win32_VideoController" )
For Each $objItem In $colItems
	If $objItem.CurrentHorizontalResolution < $Horizontal
		$RC = 1
	EndIf
	If $objItem.CurrentVerticalResolution < $Vertical
		$RC = 1
	EndIf
Next

Quit $RC

PowerShell

# Run this script with minimum required horizontal and vertical resolution in pixels
# as parameters; the return code will be 0 if both requirements are met, or 1 if not
param( [int]$minH, [int]$minV )
$rc = 0
$colItems = get-wmiobject -class "Win32_VideoController" -namespace "root/CIMV2"
foreach ( $objItem in $colItems ) {
	$horizontal = [int]$objItem.CurrentHorizontalResolution
	$vertical   = [int]$objItem.CurrentVerticalResolution
	if ( $horizontal -lt $minH ) {
		$rc = 1
	}
	if ( $vertical -lt $minV ) {
		$rc = 1
	}
}
exit $rc

VBScript

intRC     = 0
intColors = 0
intHor    = 0
intVert   = 0

' Parse the command line arguments
With WScript.Arguments.Unnamed
	If .Count = 2 Or .Count = 3 Then
		If IsNumeric( .Item(0) ) Then
			intHor  = CInt( .Item(0) )
		Else
			Syntax
		End If
		If IsNumeric( .Item(1) ) Then
			intVert = CInt( .Item(1) )
		Else
			Syntax
		End If
		If .Count = 3 Then
			If IsNumeric( .Item(2) ) Then
				intColors = CInt( .Item(2) )
			Else
				Syntax
			End If
		End If
	Else
		Syntax
	End If
End With

' Read the actual screen resolution
strQuery = "SELECT * FROM Win32_VideoController"
Set objWMIService = GetObject( "winmgmts://./root/CIMV2" )
Set colItems      = objWMIService.ExecQuery( strQuery )

' Compare the actual resolution with the minimum required values
For Each objItem In colItems
	If objItem.CurrentHorizontalResolution < intHor    Then intRC = 1
	If objItem.CurrentVerticalResolution   < intVert   Then intRC = 1
Next

Set colItems      = Nothing
Set objWMIService = Nothing

' Exit with the appropriate return code
WScript.Quit intRC


Sub Syntax
	With WScript
		.Echo "Check if the screen resolution meets your minimum requirements" & vbCrLf & vbCrLf _
			& "Usage:  " & UCase( .ScriptName ) & " min_hor min_vert" & vbCrLf & vbCrLf _
			& "Where:  ""min_hor""     is the minimum required horizontal resolution in pixels" & vbCrLf _
			& "        ""min_vert""    is the minimum required vertical resolution in pixels" & vbCrLf & vbCrLf _
			& "Note:   Return code 0 if requirements are met, 1 if not, 2 on errors"
		.Quit 2
	End With
End Sub

Video Info Without WMI

• GetSystemMetrics.exe 0 or GetSystemMetrics.exe SM_CXSCREEN return the horizontal resolution of the primary display
• GetSystemMetrics.exe 1 or GetSystemMetrics.exe SM_CYSCREEN return the vertical resolution of the primary display
• SystemInformation.exe PrimaryMonitorSize returns the horizontal and vertical resoltion of the primary display
• GetSystemMetrics.exe 80 or GetSystemMetrics.exe SM_CMONITORS or SystemInformation.exe MonitorCount return the number of connected monitors
• SystemInformation.exe MonitorsSameDisplayFormat to find out if all connected monitors have identical resolutions
• Search the registry for the maximum supported resolution by your primary display with native Windows commands only:
  
  REG.EXE Query HKLM\SYSTEM\CurrentControlSet\Enum\DISPLAY /f MaxResolution /s
  
  The output will probably look like this:
  
  

  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\DISPLAY\SAM0467\7&cf6ea47&0&UID4194576\Device Parameters
  
      MaxResolution    REG_SZ    1600,1200
  
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\DISPLAY\SAM0467\7&cf6ea47&0&UID4194578\Device Parameters
      MaxResolution    REG_SZ    1600,1200
  
  End of search: 2 match(es) found.

Use the commands GetSystemMetrics.exe /L and SystemInformation.exe (without command line argument) to list all available properties.

There is a lot of overlap in GetSystemMetrics.exe and SystemInformation.exe, decide for yourself which one works best for a particular task.

Laptop or Desktop?

To determine if the local computer is a laptop you can check the ChassisTypes property in WMI's Win32_SystemEnclosure class, and/or check if WMI's Win32_Battery class has any instances (desktops usually don't have any).

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

SET IsLaptop=0
FOR /F "delims={}" %%A IN ('WMIC.EXE Path Win32_SystemEnclosure Get ChassisTypes /Format:table') DO (
	FOR /F %%B IN ("%%~A") DO (
		SET ChassisTypes=%%B
	)
)
FOR %%A IN (%ChassisTypes%) DO (
	IF %%A GTR  7 IF %%A LSS 13 SET IsLaptop=1
	IF %%A EQU 14 SET IsLaptop=1
)

WMIC.EXE Path Win32_Battery Get Name 2>NUL | FIND "Name" >NUL
IF NOT ERRORLEVEL 1 SET /A IsLaptop += 1

IF %IsLaptop% EQU 0 ECHO This computer is definitely NOT a laptop
IF %IsLaptop% EQU 1 ECHO This computer probably is a laptop
IF %IsLaptop% EQU 2 ECHO This computer definitely is a laptop
IF %IsLaptop% GTR 2 ECHO An error occurred

KiXtart

Break On
$IsLaptop = 0
$Computer = "."
$WMIService = GetObject( "winmgmts://$Computer/root/CIMV2" )
$Items      = $WMIService.ExecQuery( "SELECT * FROM Win32_SystemEnclosure" )
For Each $Item in $Items
	For Each $SubItem In $Item.ChassisTypes
		If ( $SubItem > 7 And $SubItem < 13 ) Or $SubItem = 14
			$IsLaptop = 1
		EndIf
	Next
Next
$Items = $WMIService.ExecQuery( "SELECT * FROM Win32_Battery" )
If $Items.Count > 0
	$IsLaptop = $isLaptop + 1
EndIf
If $IsLaptop = 0
	"This computer is definitely NOT a laptop@CRLF"
EndIf
If $IsLaptop = 1
	"This computer probably is a laptop@CRLF"
EndIf
If $IsLaptop = 2
	"This computer definitely is a laptop@CRLF"
EndIf
If $IsLaptop > 2
	"An error occurred@CRLF"
EndIf
Exit $IsLaptop

PowerShell

param( [string]$computer = "." )
$IsLaptop  = 0
$instances = Get-WMIObject -Query "SELECT * FROM Win32_SystemEnclosure" -Namespace "root/cimv2" -Computername $computer
$count     = ( $instances | Measure-Object ).Count
if ( $count -gt 0 ) {
	foreach ( $item in $instances ) {
		foreach ( $type in $item.ChassisTypes ) {
			if ( ( $type -gt 7 -and $type -lt 13 ) -or $type -eq 14 ) {
				$IsLaptop = 1
			}
		}
	}
}
$instances = Get-WMIObject -Query "SELECT * FROM Win32_Battery" -Namespace "root/cimv2" -Computername $computer
$count     = ( $instances | Measure-Object ).Count
if ( $count -gt 0 ) {
	$IsLaptop += 1
}
if ( $IsLaptop -eq 0 ) { Write-Host "This computer is definitely NOT a laptop" }
if ( $IsLaptop -eq 1 ) { Write-Host "This computer probably is a laptop" }
if ( $IsLaptop -eq 2 ) { Write-Host "This computer definitely is a laptop" }
if ( $IsLaptop -gt 2 ) { Write-Host "An error occurred" }

VBScript

strComputer = "."
intIsLaptop = 0
Set objWMIService = GetObject( "winmgmts://" & strComputer & "/root/CIMV2" )
Set colItems      = objWMIService.ExecQuery( "SELECT * FROM Win32_SystemEnclosure" )
For Each objItem in colItems
	For Each objSubItem In objItem.ChassisTypes
		Select Case objSubItem
			Case  8: ' Portable
			Case  9: ' Laptop
			Case 10: ' Notebook
			Case 11: ' Hand Held
			Case 12: ' Docking Station
			Case 14: ' Sub Notebook
				intIsLaptop = 1
		End Select
	Next
Next
Set colItems = objWMIService.ExecQuery( "SELECT * FROM Win32_Battery" )
If colItems.Count > 0 Then intIsLaptop = intIsLaptop + 1
Select Case intIsLaptop
	Case 0:
		WScript.Echo "This computer is definitely NOT a laptop"
	Case 1:
		WScript.Echo "This computer probably is a laptop"
	Case 2:
		WScript.Echo "This computer definitely is a laptop"
	Case Else:
		WScript.Echo "An error occurred"
End Select
Set colItems      = Nothing
Set objWMIService = Nothing

Laptop or Desktop Without WMI

.NET's System.Windows.Forms.PowerStatus class can be used to check for battery status.
Only PowerShell has a way of directly accessing this resource, for other scripting languages I wrote a wrapper in C#: SystemInformation.exe.
Check its help text for details on its usage.

• All
• Batch
• KiXtart
• PowerShell
• VBScript

Batch

:: This batch file requires SystemInformation.exe, available at:
:: http://www.robvanderwoude.com/csharpexamples.php#SystemInformation
SET IsLaptop=3
FOR /F "tokens=2 delims={}" %%A IN ('SystemInformation.exe PowerStatus') DO SET PowerStatus=%%A
SET PowerStatus="%PowerStatus:, =","%"
FOR %%A IN (%PowerStatus%) DO SET PowerStatus.%%~A
SET PowerStatus=
IF "%PowerStatus.BatteryChargeStatus%"=="NoSystemBattery" (
	SET IsLaptop=0
) ELSE (
	IF "%PowerStatus.PowerLineStatus%"=="Online" (
		SET IsLaptop=1
	) ELSE (
		SET IsLaptop=2
	)
)

IF %IsLaptop% EQU 0 ECHO This computer is definitely NOT a laptop
IF %IsLaptop% EQU 1 ECHO This computer probably is a laptop
IF %IsLaptop% EQU 2 ECHO This computer definitely is a laptop
IF %IsLaptop% GTR 2 ECHO An error occurred

PowerShell

$IsLaptop = 3
Add-Type -Assembly System.Windows.Forms
if ( [System.Windows.Forms.SystemInformation]::PowerStatus.BatteryChargeStatus -eq 'NoSystemBattery' ) {
	$IsLaptop = 0
} else {
	if ( [System.Windows.Forms.SystemInformation]::PowerStatus.PowerLineStatus -eq 'Online' ) {
		$IsLaptop = 1
	} else {
		$IsLaptop = 2
	}
}
if ( $IsLaptop -eq 0 ) { Write-Host "This computer is definitely NOT a laptop" }
if ( $IsLaptop -eq 1 ) { Write-Host "This computer probably is a laptop" }
if ( $IsLaptop -eq 2 ) { Write-Host "This computer definitely is a laptop" }
if ( $IsLaptop -gt 2 ) { Write-Host "An error occurred" }

Sample Scripts

💾 Click the floppy disk icons to download the ZIPped sources

Related Stuff:

• Getting started with WMI scripting
• Command line WMI queries with WMIC
• Basic hardware inventories with Hardware.hta
• DEVCON, Microsoft's command line Device Manager
• DOS' DEBUG command