823 lines
22 KiB
C
823 lines
22 KiB
C
/*++
|
||
|
||
Copyright (c) 1990 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
Abstract:
|
||
|
||
Author:
|
||
|
||
Ken Reneris
|
||
|
||
Environment:
|
||
|
||
console
|
||
|
||
--*/
|
||
|
||
//
|
||
// set variable to define global variables
|
||
//
|
||
|
||
#include <tchar.h>
|
||
#include <wchar.h>
|
||
#include <nt.h>
|
||
#include <ntrtl.h>
|
||
#include <nturtl.h>
|
||
#include <windows.h>
|
||
#include <initguid.h>
|
||
#include <devguid.h>
|
||
|
||
#include <errno.h>
|
||
#include <malloc.h>
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <batclass.h>
|
||
|
||
#include <setupapi.h>
|
||
|
||
//
|
||
// Misc constants
|
||
//
|
||
#define RANGE 1
|
||
#define MAX_NUMBER_OF_BATTERIES 8
|
||
#define MAX_DEVICE_NAME_LENGTH 100
|
||
|
||
//
|
||
// Battery Device Names
|
||
//
|
||
PVOID COMPOSITE_NAME = _T("\\Device\\CompositeBattery");
|
||
|
||
//
|
||
// Globals
|
||
//
|
||
BOOLEAN LongTerm = FALSE;
|
||
|
||
#pragma pack(1)
|
||
typedef struct _ID_MAP {
|
||
UCHAR LocalId;
|
||
UCHAR ActualId;
|
||
} ID_MAP, *PID_MAP;
|
||
#pragma pack()
|
||
|
||
|
||
#pragma pack(1)
|
||
typedef struct _MFG_DATE {
|
||
|
||
UCHAR Day; // 1-31
|
||
UCHAR Month; // 1-12
|
||
USHORT Year; // 1996 - ?
|
||
} MFG_DATE, *PMFG_DATE;
|
||
#pragma pack()
|
||
|
||
|
||
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* GetBatteryDriverNames
|
||
*
|
||
* DESCRIPTION: Finds all battery class devices
|
||
*
|
||
* PARAMETERS:
|
||
* DriverNames - pointer to an array of UNICODE_STRING structures to fill in
|
||
* MaxBatteries - number of elements in DriverNames array
|
||
*
|
||
* RETURN VALUE: The number of batteries found
|
||
* Will always find the Composite battery whether it exists or not
|
||
*
|
||
*******************************************************************************/
|
||
|
||
UCHAR GetBatteryDriverNames(UNICODE_STRING * DriverNames, UCHAR MaxBatteries)
|
||
{
|
||
UCHAR driverCount, index;
|
||
DWORD reqSize;
|
||
HDEVINFO devInfo;
|
||
SP_INTERFACE_DEVICE_DATA interfaceDevData;
|
||
PSP_INTERFACE_DEVICE_DETAIL_DATA funcClassDevData;
|
||
|
||
if ((MaxBatteries == 0) || (DriverNames == NULL)) {
|
||
return 0;
|
||
}
|
||
|
||
driverCount = 0;
|
||
|
||
// Hard code the first battery to be the composite battery.
|
||
|
||
RtlInitUnicodeString (&DriverNames[driverCount], COMPOSITE_NAME);
|
||
driverCount++;
|
||
|
||
// Use the SETUPAPI.DLL interface to get the
|
||
// possible battery driver names.
|
||
devInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVICE_BATTERY, NULL, NULL,
|
||
DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
|
||
|
||
if (devInfo != INVALID_HANDLE_VALUE) {
|
||
interfaceDevData.cbSize = sizeof(SP_DEVINFO_DATA);
|
||
|
||
index = 0;
|
||
while (driverCount < MaxBatteries) {
|
||
if (SetupDiEnumInterfaceDevice(devInfo,
|
||
0,
|
||
(LPGUID)&GUID_DEVICE_BATTERY,
|
||
index,
|
||
&interfaceDevData)) {
|
||
|
||
// Get the required size of the function class device data.
|
||
SetupDiGetInterfaceDeviceDetail(devInfo,
|
||
&interfaceDevData,
|
||
NULL,
|
||
0,
|
||
&reqSize,
|
||
NULL);
|
||
|
||
funcClassDevData = malloc(reqSize);
|
||
if (funcClassDevData != NULL) {
|
||
funcClassDevData->cbSize =
|
||
sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
|
||
|
||
if (SetupDiGetInterfaceDeviceDetail(devInfo,
|
||
&interfaceDevData,
|
||
funcClassDevData,
|
||
reqSize,
|
||
&reqSize,
|
||
NULL)) {
|
||
|
||
reqSize = (lstrlen(funcClassDevData->DevicePath) + 1)
|
||
* sizeof(TCHAR);
|
||
|
||
RtlInitUnicodeString(
|
||
&DriverNames[driverCount],
|
||
funcClassDevData->DevicePath
|
||
);
|
||
driverCount++;
|
||
}
|
||
else {
|
||
printf("SetupDiGetInterfaceDeviceDetail, failed: %d", GetLastError());
|
||
}
|
||
|
||
LocalFree(funcClassDevData);
|
||
}
|
||
} else {
|
||
if (ERROR_NO_MORE_ITEMS == GetLastError()) {
|
||
break;
|
||
}
|
||
else {
|
||
printf ("SetupDiEnumInterfaceDevice, failed: %d", GetLastError());
|
||
}
|
||
}
|
||
index++;
|
||
}
|
||
SetupDiDestroyDeviceInfoList(devInfo);
|
||
}
|
||
else {
|
||
printf("SetupDiGetClassDevs on GUID_DEVICE_BATTERY, failed: %d", GetLastError());
|
||
}
|
||
return driverCount;
|
||
}
|
||
|
||
|
||
HANDLE
|
||
OpenBattery (PUNICODE_STRING BatteryName)
|
||
{
|
||
NTSTATUS status;
|
||
OBJECT_ATTRIBUTES ObjA;
|
||
IO_STATUS_BLOCK IOSB;
|
||
HANDLE driverHandle;
|
||
|
||
DWORD lastError;
|
||
|
||
|
||
// HACK: I can't seems to find the correct device
|
||
// names, so I can't open the composite battery using CreateFile()
|
||
// and I can't open the detected batteries using NtOpenFile(), so I
|
||
// have to use a different method of opening the battery depending on
|
||
// which battery it is.
|
||
if (BatteryName->Buffer == COMPOSITE_NAME) {
|
||
InitializeObjectAttributes(
|
||
&ObjA,
|
||
BatteryName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
0,
|
||
0 );
|
||
|
||
status = NtOpenFile (
|
||
&driverHandle, // return handle
|
||
SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA, // desired access
|
||
&ObjA, // Object
|
||
&IOSB, // io status block
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE, // share access
|
||
FILE_SYNCHRONOUS_IO_ALERT // open options
|
||
);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
printf ("Error opening %ws: NTSTATUS = 0x%08lx\n",
|
||
BatteryName->Buffer, status);
|
||
return NULL;
|
||
}
|
||
} else {
|
||
driverHandle = CreateFile (BatteryName->Buffer,
|
||
GENERIC_READ | GENERIC_WRITE,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
NULL,
|
||
OPEN_EXISTING,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
NULL);
|
||
|
||
if (INVALID_HANDLE_VALUE == driverHandle) {
|
||
lastError = GetLastError ();
|
||
printf ("Error opening %ws: GetLastError = 0x%08lx \n",
|
||
BatteryName->Buffer, lastError);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
printf("Opened %ws \n", BatteryName->Buffer);
|
||
|
||
return driverHandle;
|
||
}
|
||
|
||
|
||
ULONG
|
||
GetBatteryTag (HANDLE DriverHandle)
|
||
{
|
||
NTSTATUS Status;
|
||
IO_STATUS_BLOCK IOSB;
|
||
ULONG BatteryTag;
|
||
ULONG Timeout = 0;
|
||
|
||
if (LongTerm) {
|
||
Timeout = (ULONG)-1;
|
||
}
|
||
|
||
Status = NtDeviceIoControlFile(
|
||
DriverHandle,
|
||
(HANDLE) NULL, // event
|
||
(PIO_APC_ROUTINE) NULL,
|
||
(PVOID) NULL,
|
||
&IOSB,
|
||
IOCTL_BATTERY_QUERY_TAG,
|
||
&Timeout, // input buffer
|
||
sizeof (Timeout),
|
||
&BatteryTag, // output buffer
|
||
sizeof (BatteryTag)
|
||
);
|
||
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
BatteryTag = BATTERY_TAG_INVALID;
|
||
if (Status == STATUS_NO_SUCH_DEVICE) {
|
||
printf ("(Battery is not physically present or is not connected)\n");
|
||
} else {
|
||
printf ("Query Battery tag failed: Status = %x\n", Status);
|
||
}
|
||
|
||
}
|
||
|
||
printf("Battery Tag = 0x%08lx.\n", BatteryTag);
|
||
return BatteryTag;
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
GetBatteryInfo (
|
||
HANDLE DriverHandle,
|
||
ULONG BatteryTag,
|
||
IN BATTERY_QUERY_INFORMATION_LEVEL Level,
|
||
OUT PVOID Buffer,
|
||
IN ULONG BufferLength
|
||
)
|
||
{
|
||
NTSTATUS Status;
|
||
IO_STATUS_BLOCK IOSB;
|
||
BATTERY_QUERY_INFORMATION BInfo;
|
||
|
||
memset (Buffer, 0, BufferLength);
|
||
BInfo.BatteryTag = BatteryTag;
|
||
BInfo.InformationLevel = Level;
|
||
BInfo.AtRate = 0; // This is needed for reading estimated time correctly.
|
||
|
||
Status = NtDeviceIoControlFile(
|
||
DriverHandle,
|
||
(HANDLE) NULL, // event
|
||
(PIO_APC_ROUTINE) NULL,
|
||
(PVOID) NULL,
|
||
&IOSB,
|
||
IOCTL_BATTERY_QUERY_INFORMATION,
|
||
&BInfo, // input buffer
|
||
sizeof (BInfo),
|
||
Buffer, // output buffer
|
||
BufferLength
|
||
);
|
||
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
|
||
if ((Status == STATUS_INVALID_PARAMETER) ||
|
||
(Status == STATUS_INVALID_DEVICE_REQUEST) ||
|
||
(Status == STATUS_NOT_SUPPORTED)) {
|
||
|
||
printf ("Not Supported by Battery, Level %x, Status: %x\n", Level, Status);
|
||
} else {
|
||
printf ("Query failed: Level %x, Status = %x\n", Level, Status);
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
|
||
VOID
|
||
GetBatteryStatus (
|
||
HANDLE DriverHandle,
|
||
IN PBATTERY_WAIT_STATUS WaitStatus,
|
||
IN PBATTERY_INFORMATION BInfo,
|
||
OUT PBATTERY_STATUS BatteryStatus
|
||
)
|
||
{
|
||
NTSTATUS Status;
|
||
IO_STATUS_BLOCK IOSB;
|
||
ULONG Volts;
|
||
|
||
|
||
memset (BatteryStatus, 0xAB, sizeof(BatteryStatus));
|
||
|
||
Status = NtDeviceIoControlFile(
|
||
DriverHandle,
|
||
(HANDLE) NULL, // event
|
||
(PIO_APC_ROUTINE) NULL,
|
||
(PVOID) NULL,
|
||
&IOSB,
|
||
IOCTL_BATTERY_QUERY_STATUS,
|
||
WaitStatus, // input buffer
|
||
sizeof (BATTERY_WAIT_STATUS),
|
||
BatteryStatus, // output buffer
|
||
sizeof (BATTERY_STATUS)
|
||
);
|
||
|
||
//
|
||
// dump battery status
|
||
//
|
||
printf ("[Current Status Information]\n");
|
||
printf (" Power State...........: ");
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
printf ("Query failed: Status = %x\n", Status);
|
||
return ;
|
||
}
|
||
|
||
|
||
//
|
||
// Print the PowerState
|
||
//
|
||
|
||
printf ("%08x ", BatteryStatus->PowerState);
|
||
|
||
if (BatteryStatus->PowerState & BATTERY_POWER_ON_LINE) {
|
||
printf ("Power_Online ");
|
||
}
|
||
|
||
if (BatteryStatus->PowerState & BATTERY_DISCHARGING) {
|
||
printf ("Discharging ");
|
||
}
|
||
|
||
if (BatteryStatus->PowerState & BATTERY_CHARGING) {
|
||
printf ("Charging ");
|
||
}
|
||
|
||
if (BatteryStatus->PowerState & BATTERY_CRITICAL) {
|
||
printf ("Critical! ");
|
||
}
|
||
|
||
if (BatteryStatus->PowerState == 0) {
|
||
printf ("No flags set.");
|
||
}
|
||
|
||
printf ("\n");
|
||
|
||
|
||
//
|
||
// Print the Voltage
|
||
//
|
||
|
||
Volts = BatteryStatus->Voltage;
|
||
if (Volts == BATTERY_UNKNOWN_VOLTAGE) {
|
||
printf (" Voltage...............: %08x UNKNOWN\n", Volts);
|
||
} else {
|
||
printf (" Voltage...............: %08x %d.%03d V\n", Volts, (Volts/1000), Volts - ((Volts/1000)*1000));
|
||
}
|
||
|
||
|
||
//
|
||
// Print the Rate
|
||
//
|
||
|
||
if (BatteryStatus->Rate == BATTERY_UNKNOWN_RATE) {
|
||
printf (" Rate..................: %08x UNKNOWN\n", BatteryStatus->Rate);
|
||
} else {
|
||
if (BInfo->Capabilities & BATTERY_CAPACITY_RELATIVE) {
|
||
printf (" Rate..................: %08x %d % per hour ", BatteryStatus->Rate, BatteryStatus->Rate);
|
||
} else {
|
||
printf (" Rate..................: %08x %d mW ", BatteryStatus->Rate, BatteryStatus->Rate);
|
||
}
|
||
|
||
if (BatteryStatus->PowerState & BATTERY_CHARGING) {
|
||
printf ("(Charging)\n");
|
||
} else if (BatteryStatus->PowerState & BATTERY_DISCHARGING) {
|
||
printf ("(Discharging)\n");
|
||
} else {
|
||
printf ("(Quiescent)\n");
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Print the Current Capacity
|
||
//
|
||
|
||
if (BatteryStatus->Capacity == BATTERY_UNKNOWN_CAPACITY) {
|
||
printf (" Current Battery Charge: %08x UNKNOWN\n");
|
||
} else {
|
||
printf (" Current Battery Charge: %08x ", BatteryStatus->Capacity);
|
||
|
||
if (BatteryStatus->Capacity == 0xFFFF) {
|
||
printf ("Invalid");
|
||
} else {
|
||
printf ("%d mWh ", BatteryStatus->Capacity);
|
||
}
|
||
if ((BInfo->FullChargedCapacity != 0) &
|
||
(BInfo->FullChargedCapacity != BATTERY_UNKNOWN_CAPACITY)){
|
||
printf ("(%d%%)",
|
||
BatteryStatus->Capacity * 100 / BInfo->FullChargedCapacity);
|
||
}
|
||
printf ("\n");
|
||
}
|
||
|
||
printf ("\n");
|
||
}
|
||
|
||
|
||
|
||
|
||
void
|
||
QueryBattery (PUNICODE_STRING BatteryName)
|
||
{
|
||
HANDLE driverHandle;
|
||
ULONG batteryTag;
|
||
BATTERY_INFORMATION BInfo;
|
||
ULONG BETime;
|
||
UCHAR BDeviceName[50];
|
||
MFG_DATE BManDate;
|
||
UCHAR BManName[50];
|
||
ULONG BETemp;
|
||
UCHAR BEUID[50];
|
||
BATTERY_REPORTING_SCALE BEGran[4];
|
||
BATTERY_WAIT_STATUS WStat;
|
||
BATTERY_STATUS BStat;
|
||
ULONG i;
|
||
ULONG Cent;
|
||
ULONG Far;
|
||
UCHAR PrivateLevel;
|
||
ULONG Bdata;
|
||
UCHAR Bblock[50];
|
||
|
||
if ((driverHandle = OpenBattery (BatteryName)) == NULL) {
|
||
return;
|
||
}
|
||
|
||
printf ("Opened driver w/handle %d\n", driverHandle);
|
||
|
||
batteryTag = GetBatteryTag (driverHandle);
|
||
if (batteryTag == BATTERY_TAG_INVALID) {
|
||
NtClose(driverHandle);
|
||
return;
|
||
}
|
||
|
||
printf ("[Static Information]\n");
|
||
printf (" Battery Tag...........: %x\n", batteryTag);
|
||
|
||
//
|
||
// Get generic info
|
||
//
|
||
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryInformation, &BInfo, sizeof(BInfo))) {
|
||
|
||
//
|
||
// Print the Capabilities
|
||
//
|
||
|
||
printf (" Capabilities..........: ");
|
||
|
||
printf ("%08x ", BInfo.Capabilities);
|
||
|
||
if (BInfo.Capabilities & BATTERY_SYSTEM_BATTERY) {
|
||
printf ("System ");
|
||
}
|
||
|
||
if (BInfo.Capabilities & BATTERY_CAPACITY_RELATIVE) {
|
||
printf ("Capacity_Relative ");
|
||
}
|
||
|
||
if (BInfo.Capabilities & BATTERY_IS_SHORT_TERM) {
|
||
printf ("Short_Term ");
|
||
}
|
||
printf ("\n");
|
||
|
||
|
||
//
|
||
// Print the Technology
|
||
//
|
||
|
||
printf (" Technology............: %08x ", BInfo.Technology);
|
||
|
||
if (BInfo.Technology == 0) {
|
||
printf ("Primary Battery ");
|
||
} else if (BInfo.Technology == 1) {
|
||
printf ("Secondary Battery ");
|
||
} else {
|
||
printf ("Unknown ");
|
||
}
|
||
printf ("\n");
|
||
|
||
|
||
//
|
||
// Print the Chemistry
|
||
//
|
||
|
||
printf (" Chemistry.............: %4.4s\n", BInfo.Chemistry);
|
||
|
||
|
||
//
|
||
// Print the Designed Capacity
|
||
//
|
||
|
||
printf (" Designed Capacity.....: ");
|
||
|
||
if (BInfo.DesignedCapacity == BATTERY_UNKNOWN_CAPACITY) {
|
||
printf ("%08x UNKNOWN\n", BInfo.DesignedCapacity);
|
||
} else {
|
||
if (BInfo.Capabilities & BATTERY_CAPACITY_RELATIVE) {
|
||
printf ("%08x %d%%\n", BInfo.DesignedCapacity, BInfo.DesignedCapacity);
|
||
} else {
|
||
printf ("%08x %d mWh\n", BInfo.DesignedCapacity, BInfo.DesignedCapacity);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Print the Full Charged Capacity
|
||
//
|
||
|
||
printf (" Full Charged Capacity.: ");
|
||
|
||
if (BInfo.FullChargedCapacity == BATTERY_UNKNOWN_CAPACITY) {
|
||
printf ("%08x UNKNOWN\n", BInfo.FullChargedCapacity);
|
||
} else {
|
||
if (BInfo.Capabilities & BATTERY_CAPACITY_RELATIVE) {
|
||
printf ("%08x %d%%\n", BInfo.FullChargedCapacity, BInfo.FullChargedCapacity);
|
||
} else {
|
||
printf ("%08x %d mWh\n", BInfo.FullChargedCapacity, BInfo.FullChargedCapacity);
|
||
}
|
||
}
|
||
|
||
if ((BInfo.FullChargedCapacity == 0) ||
|
||
(BInfo.FullChargedCapacity == BATTERY_UNKNOWN_CAPACITY)){
|
||
//
|
||
// Print Alert 1
|
||
//
|
||
|
||
printf (" Default Alert1 (crit).: %08x %d mWh\n",
|
||
BInfo.DefaultAlert1, BInfo.DefaultAlert1);
|
||
|
||
|
||
//
|
||
// Print Alert 2
|
||
//
|
||
|
||
printf (" Default Alert2 (low)..: %08x %d mWh (%d%%)\n",
|
||
BInfo.DefaultAlert2, BInfo.DefaultAlert2);
|
||
|
||
} else {
|
||
|
||
//
|
||
// Print Alert 1
|
||
//
|
||
|
||
printf (" Default Alert1 (crit).: %08x %d mWh (%d%%)\n",
|
||
BInfo.DefaultAlert1, BInfo.DefaultAlert1,
|
||
(BInfo.DefaultAlert1*100)/BInfo.FullChargedCapacity);
|
||
|
||
|
||
//
|
||
// Print Alert 2
|
||
//
|
||
|
||
printf (" Default Alert2 (low)..: %08x %d mWh (%d%%)\n",
|
||
BInfo.DefaultAlert2, BInfo.DefaultAlert2,
|
||
(BInfo.DefaultAlert2*100)/BInfo.FullChargedCapacity);
|
||
}
|
||
|
||
//
|
||
// Print the Critical Bias
|
||
//
|
||
|
||
printf (" Critical Bias.........: %08x\n", BInfo.CriticalBias);
|
||
|
||
|
||
//
|
||
// Print the Cycle Count
|
||
//
|
||
|
||
printf (" Cycle Count...........: %08x %d\n", BInfo.CycleCount, BInfo.CycleCount);
|
||
}
|
||
|
||
|
||
//
|
||
// Print the battery granularity
|
||
//
|
||
|
||
printf (" Granularity...........: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryGranularityInformation, BEGran, sizeof(BEGran))) {
|
||
|
||
printf ("%08x Capacity(1) %08x\n", BEGran[0].Granularity, BEGran[0].Capacity);
|
||
|
||
for (i = 1; i < 4; i++) {
|
||
if ((BEGran[i].Granularity != -1) && (BEGran[i].Granularity != 0)) {
|
||
printf (" %08x Capacity(%d) %08x\n",
|
||
BEGran[i].Granularity, (i+1), BEGran[i].Capacity);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Print the temperature
|
||
//
|
||
|
||
printf (" Temperature...........: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryTemperature, &BETemp, sizeof(BETemp))) {
|
||
printf ("%08x", BETemp);
|
||
|
||
//
|
||
// Print temp as something reasonable - Centigrade and Fahrenheit
|
||
//
|
||
if (BETemp > 0) {
|
||
Cent = (BETemp/10) - 273;
|
||
Far = ((Cent*2) - (Cent/5)) + 32;
|
||
printf (" %d C %d F", Cent, Far);
|
||
}
|
||
printf ("\n");
|
||
}
|
||
|
||
|
||
//
|
||
// Print the Unique ID
|
||
//
|
||
|
||
printf (" Unique ID.............: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryUniqueID, BEUID, sizeof(BEUID))) {
|
||
printf ("%ws\n", BEUID);
|
||
}
|
||
|
||
|
||
//
|
||
// Print the estimated run time
|
||
//
|
||
|
||
printf (" Estimated Runtime.....: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryEstimatedTime, &BETime, sizeof(BETime))) {
|
||
printf ("%08x ", BETime);
|
||
|
||
if (BETime != BATTERY_UNKNOWN_TIME) {
|
||
printf ("%d Seconds ", BETime);
|
||
printf ("(%d:%d:%d)", BETime / 3600, (BETime % 3600) / 60, (BETime % 3600) % 60);
|
||
} else {
|
||
printf ("Not Available");
|
||
}
|
||
printf ("\n");
|
||
}
|
||
|
||
|
||
//
|
||
// Print the device name
|
||
//
|
||
|
||
printf (" Device Name...........: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryDeviceName, BDeviceName, sizeof(BDeviceName))) {
|
||
printf ("%ws\n", BDeviceName);
|
||
}
|
||
|
||
|
||
//
|
||
// Print the manufacture date
|
||
//
|
||
|
||
printf (" Manufacture Date......: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryManufactureDate, &BManDate, sizeof(BManDate))) {
|
||
printf ("%02X%02X%04X %02d/%02d/%d\n", BManDate.Month, BManDate.Day, BManDate.Year,
|
||
BManDate.Month, BManDate.Day, BManDate.Year);
|
||
}
|
||
|
||
|
||
//
|
||
// Print the manufacturer name
|
||
//
|
||
|
||
printf (" Manufacturer Name.....: ");
|
||
if (GetBatteryInfo (driverHandle, batteryTag, BatteryManufactureName, BManName, sizeof(BManName))) {
|
||
printf ("%ws\n", BManName);
|
||
}
|
||
|
||
printf ("\n");
|
||
|
||
|
||
//
|
||
// Get the battery status and print it out
|
||
//
|
||
|
||
memset (&WStat, 0, sizeof(WStat));
|
||
WStat.BatteryTag = batteryTag;
|
||
|
||
GetBatteryStatus (driverHandle, &WStat, &BInfo, &BStat);
|
||
|
||
//
|
||
// If the user requested it perform a long term status change request
|
||
//
|
||
|
||
if (LongTerm) {
|
||
|
||
printf ("Starting long-term status change request (5 min.)\n");
|
||
|
||
WStat.PowerState = BStat.PowerState;
|
||
WStat.LowCapacity = BStat.Capacity - RANGE;
|
||
WStat.HighCapacity = BStat.Capacity + RANGE;
|
||
WStat.Timeout = 50000000; // 5 min
|
||
GetBatteryStatus (driverHandle, &WStat, &BInfo, &BStat);
|
||
}
|
||
|
||
NtClose(driverHandle);
|
||
}
|
||
|
||
|
||
int
|
||
__cdecl
|
||
main(USHORT argc, CHAR **argv)
|
||
{
|
||
ULONG battTag;
|
||
ULONG battNum;
|
||
ULONG RetVal;
|
||
UCHAR param;
|
||
UNICODE_STRING batteries [MAX_NUMBER_OF_BATTERIES];
|
||
UCHAR numBatts;
|
||
|
||
|
||
RtlZeroMemory (batteries, sizeof(UNICODE_STRING)*MAX_NUMBER_OF_BATTERIES);
|
||
|
||
_tprintf (_T("Parameters: [L] - Issue Long-term status change request\n"));
|
||
|
||
if (argc > 1) {
|
||
param = argv[1][0];
|
||
|
||
if ((param == 'l') || param == 'L') {
|
||
LongTerm = TRUE;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
while (1) {
|
||
|
||
numBatts = GetBatteryDriverNames (batteries, MAX_NUMBER_OF_BATTERIES);
|
||
|
||
printf ("\n");
|
||
for (battNum = 0; battNum < numBatts; battNum++) {
|
||
_tprintf(_T("Batt#%d: %s \n"), battNum, batteries[battNum].Buffer);
|
||
}
|
||
|
||
printf ("\nBattery Number: ");
|
||
if (scanf ("%d", &battNum) != 1) {
|
||
return 0; // Program exit
|
||
}
|
||
printf ("\n");
|
||
|
||
if (battNum < numBatts) {
|
||
|
||
QueryBattery (&batteries [battNum]);
|
||
|
||
} else {
|
||
printf ("Invalid Battery Number\n");
|
||
}
|
||
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|