Eigenschaften von Installierten Akkus (Batterien) ermitteln

[torsti.j]

Delphi-Quellcode:

unit UBatterieFunktionen;

interface

uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Activex,StdCtrls, ExtCtrls, Registry, ComCtrls,
  ImgList, ShellAPI;

type
  SP_DEVICE_INTERFACE_DATA = record
    cbSize: DWORD;
    Guid: TGUID;
    Flags: DWORD;
    Reserve: Pointer;
  end;

type
  PSP_DEVICE_INTERFACE_DATA = ^SP_DEVICE_INTERFACE_DATA;

type
  SP_DEVICE_INTERFACE_DETAIL_DATA = packed record
    cbSize: DWORD;
    DevicePath: array[0..0] of AnsiChar;
  end;

type
  PSP_DEVICE_INTERFACE_DETAIL_DATA = ^SP_DEVICE_INTERFACE_DETAIL_DATA;

  BATTERY_QUERY_INFORMATION_LEVEL = (
    BatteryInformation,
    BatteryGranularityInformation,
    BatteryTemperature,
    BatteryEstimatedTime,
    BatteryDeviceName,
    BatteryManufactureDate,
    BatteryManufactureName,
    BatteryUniqueID,
    BatterySerialNumber);
  TBatteryQueryInformationLevel = BATTERY_QUERY_INFORMATION_LEVEL;

  _BATTERY_QUERY_INFORMATION = record
    BatteryTag: ULONG;
    InformationLevel: BATTERY_QUERY_INFORMATION_LEVEL;
    AtRate: integer;
  end;
  BATTERY_QUERY_INFORMATION = _BATTERY_QUERY_INFORMATION;
  PBATTERY_QUERY_INFORMATION = ^BATTERY_QUERY_INFORMATION;
  TBatteryQueryInformation = BATTERY_QUERY_INFORMATION;
  PBatteryQueryInformation = PBATTERY_QUERY_INFORMATION;

  _BATTERY_INFORMATION = record
    Capabilities: ULONG;
    Technology: UCHAR;
    Reserved: array[0..2] of UCHAR;
    Chemistry: array[0..3] of UCHAR;
    DesignedCapacity: ULONG;
    FullChargedCapacity: ULONG;
    DefaultAlert1: ULONG;
    DefaultAlert2: ULONG;
    CriticalBias: ULONG;
    CycleCount: ULONG;
  end;
  BATTERY_INFORMATION = _BATTERY_INFORMATION;
  PBATTERY_INFORMATION = ^BATTERY_INFORMATION;
  TBatteryInformation = BATTERY_INFORMATION;
  PBatteryInformation = PBATTERY_INFORMATION;

type
  TGUID = record
    Data1: DWORD;
    Data2: Word;
    Data3: Word;
    Data4: array[0..7] of Byte;
  end;

type
  LPGUID = ^TGUID;

type
  SP_DEVINFO_DATA = record
    cbSize: DWord;
    Guid: TGUID;
    DevInst: DWORD;
    Reserve: DWORD;
  end;

type
  PSP_DEVINFO_DATA = ^SP_DEVINFO_DATA;


type
  TSetupDiGetClassDevs = function(const ClassGuid: LPGUID; Enumerator: LPCTSTR; hwndParent: HWND; Flags: DWORD): Pointer; stdcall;
  TSetupDiEnumDeviceInterfaces = function(DeviceInfoSet: Pointer; DeviceInfoData: PSP_DEVINFO_DATA; const InterfaceClassGuid: LPGUID; MemberIndex: DWORD; DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA): Boolean; stdcall;
  TSetupDiGetDeviceInterfaceDetail = function(DeviceInfoSet: Pointer; DeviceInterfaceData: PSP_DEVICE_INTERFACE_DATA; DeviceInterfaceDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA; DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD; DeviceInfoData: PSP_DEVINFO_DATA): Boolean; stdcall;
  TSetupDiDestroyDeviceInfoList = function(DeviceInfoSet: Pointer): Boolean; stdcall;

const
  GUID_DEVICE_BATTERY: TGUID = (Data1: $72631E54; Data2: $78A4; Data3: $11D0; Data4: ($BC, $F7, $00, $AA, $00, $B7, $B3, $2A));

type //für den Record _BATTERY_MANUFACTURE_DATE
  USHORT = Word;

type //für die Funktion WerteAuslesen
  _BATTERY_MANUFACTURE_DATE = record
    Day: UCHAR;
    Month: UCHAR;
    Year: USHORT;
  end;
  BATTERY_MANUFACTURE_DATE = _BATTERY_MANUFACTURE_DATE;
  PBATTERY_MANUFACTURE_DATE = ^BATTERY_MANUFACTURE_DATE;
  TBatteryManufactureDate = BATTERY_MANUFACTURE_DATE;
  PBatteryManufactureDate = PBATTERY_MANUFACTURE_DATE;

  _BATTERY_WAIT_STATUS = record
    BatteryTag: ULONG;
    Timeout: ULONG;
    PowerState: ULONG;
    LowCapacity: ULONG;
    HighCapacity: ULONG;
  end;
  BATTERY_WAIT_STATUS = _BATTERY_WAIT_STATUS;
  PBATTERY_WAIT_STATUS = ^BATTERY_WAIT_STATUS;
  TBatteryWaitStatus = BATTERY_WAIT_STATUS;
  PBatteryWaitStatus = PBATTERY_WAIT_STATUS;

  _BATTERY_STATUS = record
    PowerState: ULONG;
    Capacity: ULONG;
    Voltage: ULONG;
    Rate: integer;
  end;
  BATTERY_STATUS = _BATTERY_STATUS;
  PBATTERY_STATUS = ^BATTERY_STATUS;
  TBatteryStatus = BATTERY_STATUS;
  PBatteryStatus = PBATTERY_STATUS;

type  //für die Funktion WerteAuslesen
  _BATTERY_REPORTING_SCALE = record
    Granularity: DWORD;
    Capacity: DWORD;
  end;
  BATTERY_REPORTING_SCALE = _BATTERY_REPORTING_SCALE;
  PBATTERY_REPORTING_SCALE = ^BATTERY_REPORTING_SCALE;
  TBatteryReportingScale = BATTERY_REPORTING_SCALE;
  PBatteryReportingScale = PBATTERY_REPORTING_SCALE;

const //für IOCTL_BATTERY_QUERY
  DIGCF_DEFAULT = $00000001;
  DIGCF_PRESENT = $00000002;
  DIGCF_ALLCLASSES = $00000004;
  DIGCF_PROFILE = $00000008;
  DIGCF_DEVICEINTERFACE = $00000010;
  FILE_DEVICE_BATTERY = $00000029;
  FILE_READ_ACCESS = $0001;
  METHOD_BUFFERED = 0;

  BATTERY_CAPACITY_RELATIVE = $40000000;
  BATTERY_IS_SHORT_TERM = $20000000;
  BATTERY_SET_CHARGE_SUPPORTED = $00000001;
  BATTERY_SET_DISCHARGE_SUPPORTED = $00000002;
  BATTERY_SYSTEM_BATTERY = $80000000;

const //für die Funktion WerteAuslesen
  BATTERY_CHARGING = $00000004;
  BATTERY_CRITICAL = $00000008;
  BATTERY_DISCHARGING = $00000002;
  BATTERY_POWER_ON_LINE = $00000001;

const //für die Funktion WerteAuslesen
  BATTERY_UNKNOWN_RATE = $80000000;

  IOCTL_BATTERY_QUERY_INFORMATION = (FILE_DEVICE_BATTERY shl 16) or (FILE_READ_ACCESS shl 14) or ($11 shl 2) or METHOD_BUFFERED;
  IOCTL_BATTERY_QUERY_TAG = (FILE_DEVICE_BATTERY shl 16) or (FILE_READ_ACCESS shl 14) or ($10 shl 2) or METHOD_BUFFERED;
  IOCTL_BATTERY_QUERY_STATUS = (FILE_DEVICE_BATTERY shl 16) or (FILE_READ_ACCESS shl 14) or ($13 shl 2) or METHOD_BUFFERED;

//-----------------------------------------
//-----------------------------------------

type
  TBatterieFunktionen = class
  private
    //Neue Variablen ab hier:
    SetupDiGetClassDevs: TSetupDiGetClassDevs;
    SetupDiEnumDeviceInterfaces: TSetupDiEnumDeviceInterfaces;
    SetupDiGetDeviceInterfaceDetail: TSetupDiGetDeviceInterfaceDetail;
    SetupDiDestroyDeviceInfoList: TSetupDiDestroyDeviceInfoList;
    //Neue Funktionen ab hier:
    function AkkusAufzaehlen(): Cardinal;
    procedure UnitCreate;
  public
    //Neue Variablen ab hier:
    Netzbetrieb: bool;
    Powerstatus: string;
    AktuelleKapazität: integer; //in mWh = Ladezustand
    AktuelleSpannung: integer; //in mV = Volt
    AktuelleStromstaerke: integer; //in mA
    AktuelleRate: integer; //in mWh = MG  (Energiefluss)
    AkkuHersteller: string;
    AkkuHerstellerDatum: string;
    AkkuName: string;
    AkkuNummer: string;
    AkkuID: string;
    AkkuChemie: string;
    AkkuTechnologie: string;
    AkkuFunktion: string;
    AkkuUnterteilungen:array[0..3] of Integer;  //in mWh
    AkkuKapazitäten:array[0..3] of Integer;     //in mWh
    AkkuKapazitätAngabe: integer;  //in mWh
    AkkuKapazitätVoll: integer;    //in mWh = Wattvoll
    AkkuRestZeit: integer;   //in Minuten
    AkkuGesamtZeit: integer; //in Minuten
    AkkuLadeZyklen:integer;
    AkkuAlarm1:integer;  // bei ... mWh
    AkkuAlarm2:integer;  // bei ... mWh
    AkkuKritisch:integer;// bei ... mWh
    AkkuTemperatur:integer; // in GradCelsius;
    Akkuanzahl: cardinal;
    VorhandeneAkkus: Array of String;
    AkkuStatus: string;
    AkkuProzente: integer;
    //Neue Funktionen ab hier:
    procedure WerteAktualisieren(Batterienummer:integer);
    //zu GetAccuStatus------------------------------------------
    function GetAccuStatus(MeldungAnzeigen: boolean): boolean;
    Constructor Create;
  end;

var
  BatterieFunktionen : TBatterieFunktionen;

implementation

Constructor TBatterieFunktionen.Create;
begin
   UnitCreate;
end;
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Kurz info: diese Funktion erhöht den Speicherbedarf je aufruf!
function TBatterieFunktionen.GetAccuStatus(MeldungAnzeigen: boolean): boolean;
var
   SystemPowerStatus: TSystemPowerStatus;
   Meldung:String;
begin
  result:=false;
  GetSystemPowerStatus(SystemPowerStatus);
  with SystemPowerStatus do begin
    // Wird das System mit Wechselstrom oder Akku betrieben ?
    case ACLineStatus of
      0:   Meldung:='System wird mit Akku betrieben';
      1:   Meldung:='System wird mit Wechselstrom betrieben';
      else Meldung:='Unbekannter Status';
    end;
    // +Ladezustand der Batterie
    case BatteryFlag of
      1 :  Meldung:=Meldung+', im Ladezustand'; //Hoher
      2 :  Meldung:=Meldung+', Achtung! Niedriger Ladezustand';
      4 :  Meldung:=Meldung+', Achtung! Kritischer Ladezustand';
      8 :  Meldung:=Meldung+', Die Batterie wird geladen';
      128: Meldung:=Meldung+', Es existiert keine System-Batterie';
      255: Meldung:=Meldung+', Unbekannter Status';
    end;
    AkkuStatus:= Meldung;
    // +Ladezustand in Prozent
    if BatteryLifePercent <> 255 then
      AkkuProzente:=BatteryLifePercent
    else
      AkkuProzente:=-1;

    if (ACLineStatus = 0) and (Meldung <> '') then begin
        if MeldungAnzeigen then ShowMessage(Meldung);
        result:=true;
    end;
  end;
end;
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Kurz info
function TBatterieFunktionen.AkkusAufzaehlen(): Cardinal;
var
  DeviceInfo: Pointer;
  DeviceInterfaceData: SP_DEVICE_INTERFACE_DATA;
  RequiredSize: DWORD;
  DevicePath: String;
  PDeviceInformationDetailData: PSP_DEVICE_INTERFACE_DETAIL_DATA;
begin
  Result := 0;
  Finalize(VorhandeneAkkus);
  Try
    DeviceInfo := SetupDiGetClassDevs(@GUID_DEVICE_BATTERY, nil, 0, DIGCF_PRESENT or DIGCF_DEVICEINTERFACE);
  except
    DeviceInfo := nil;
  end;
  while DeviceInfo<>nil do
  begin
    DeviceInterfaceData.cbSize := SizeOf(DeviceInterfaceData);
    if not SetupDiEnumDeviceInterfaces(DeviceInfo, nil, @GUID_DEVICE_BATTERY, Result, @DeviceInterfaceData) then
      Break;
    SetupDiGetDeviceInterfaceDetail(DeviceInfo, @DeviceInterfaceData, nil, 0, @RequiredSize, nil);
    PDeviceInformationDetailData := AllocMem(RequiredSize + SizeOf(SP_DEVICE_INTERFACE_DETAIL_DATA));
    PDeviceInformationDetailData.cbSize := SizeOf(SP_DEVICE_INTERFACE_DETAIL_DATA);
    SetupDiGetDeviceInterfaceDetail(DeviceInfo, @DeviceInterfaceData, PDeviceInformationDetailData, RequiredSize, @RequiredSize, nil);
    DevicePath := PChar(@PDeviceInformationDetailData^.DevicePath);
    FreeMem(PDeviceInformationDetailData);
    Inc(Result);
    SetLength(VorhandeneAkkus, Result);
    VorhandeneAkkus[Result - 1] := DevicePath;
  end;
  if DeviceInfo <> nil then SetupDiDestroyDeviceInfoList(DeviceInfo);
end;
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Kurz info
procedure TBatterieFunktionen.UnitCreate;
var
  hLibrary: HMODULE;
  i: Cardinal;
begin
  //-------------------------------------------
  Netzbetrieb:=true;
  try
      hLibrary := LoadLibrary('setupapi.dll');
      if hLibrary <> 0 then
      begin
          @SetupDiGetClassDevs := GetProcAddress(hLibrary, 'SetupDiGetClassDevsA');
          @SetupDiEnumDeviceInterfaces := GetProcAddress(hLibrary, 'SetupDiEnumDeviceInterfaces');
          @SetupDiGetDeviceInterfaceDetail := GetProcAddress(hLibrary, 'SetupDiGetDeviceInterfaceDetailA');
          @SetupDiDestroyDeviceInfoList := GetProcAddress(hLibrary, 'SetupDiDestroyDeviceInfoList');
      end;
      Akkuanzahl := Akkusaufzaehlen();
   except end;
   WerteAktualisieren(0);
end;
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Kurz info
procedure TBatterieFunktionen.WerteAktualisieren(Batterienummer:integer);
var
  i, hBattery: Cardinal;
  lpBytesReturned: DWORD;
  BQI: TBatteryQueryInformation;
  BI: TBatteryInformation;
  BS: TBatteryStatus;
  BMD: TBatteryManufactureDate;
  BWS: TBatteryWaitStatus;
  BRS: array[0..3] of BATTERY_REPORTING_SCALE;
  OutBuffer: PWideChar;
begin
  if (AkkusAufzaehlen > 0) then
  begin
    hBattery := CreateFile(PAnsiChar(VorhandeneAkkus[Batterienummer]), GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
    DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_TAG, nil, 0, @i, SizeOf(Cardinal), lpBytesReturned, nil);
    ZeroMemory(@BQI, SizeOf(BATTERY_QUERY_INFORMATION));
    BQI.BatteryTag := i;
    BWS.BatteryTag := BQI.BatteryTag;
    BWS.Timeout := 1;
    BS.PowerState := 0;
    BS.Capacity := 0;
    //Powerstatus:
    DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_STATUS, @BWS, SizeOf(BWS), @BS, SizeOf(BS), lpBytesReturned, nil);
    Powerstatus := ''; Netzbetrieb:=false;
    if BS.PowerState and BATTERY_CHARGING = BATTERY_CHARGING then begin
      Powerstatus := ('Aufladen');
    end else if BS.PowerState and BATTERY_CRITICAL = BATTERY_CRITICAL then begin
      Powerstatus := ('Kritisch');
    end else if BS.PowerState and BATTERY_DISCHARGING = BATTERY_DISCHARGING then begin
      Powerstatus := ('Entladen');
    end else if BS.PowerState and BATTERY_POWER_ON_LINE = BATTERY_POWER_ON_LINE then begin
      Powerstatus := ('Netzbetrieb');
      Netzbetrieb:=true;
    end;
    //-------------------
    //Aktuelle Kapazität:
    AktuelleKapazität := BS.Capacity;
    //-------------------
    //Aktuelle Spannung:
    if BS.Voltage = $FFFFFFFF then   AktuelleSpannung := 0
    else                             AktuelleSpannung := BS.Voltage;
    //-------------------
    //Rate:
    if BS.Rate = BATTERY_UNKNOWN_RATE then   AktuelleRate := 0
    else                                     AktuelleRate := BS.Rate;
    //-------------------
    OutBuffer := AllocMem(MAX_PATH + 1);
    //Informationen:
    try
      BQI.InformationLevel := BatteryManufactureName;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), OutBuffer, 255, lpBytesReturned, nil) then
        AkkuHersteller := WideCharToString(OutBuffer);
      //-----------------
      BQI.InformationLevel := BatteryDeviceName;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), OutBuffer, 255, lpBytesReturned, nil) then
        AkkuName := WideCharToString(OutBuffer);
      //-----------------
      BQI.InformationLevel := BatterySerialNumber;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), OutBuffer, 255, lpBytesReturned, nil) then
        AkkuNummer := WideCharToString(OutBuffer);
      //-----------------
      BQI.InformationLevel := BatteryUniqueID;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), OutBuffer, 255, lpBytesReturned, nil) then
        AkkuID := WideCharToString(OutBuffer);
      //-----------------
      for i := 0 to 3 do
      begin
        BRS[i].Granularity := 0;
        AkkuUnterteilungen[i] := 0;
        BRS[i].Capacity := 0;
        AkkuKapazitäten[i] := 0;
      end;
      BQI.InformationLevel := BatteryGranularityInformation;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), @BRS, SizeOf(BRS), lpBytesReturned, nil) then
      begin
        AkkuUnterteilungen[0]:=BRS[0].Granularity;
        AkkuUnterteilungen[1]:=BRS[1].Granularity;
        AkkuUnterteilungen[2]:=BRS[2].Granularity;
        AkkuUnterteilungen[3]:=BRS[3].Granularity;
        AkkuKapazitäten[0]:=BRS[0].Capacity;
        AkkuKapazitäten[1]:=BRS[1].Capacity;
        AkkuKapazitäten[2]:=BRS[2].Capacity;
        AkkuKapazitäten[3]:=BRS[3].Capacity;
      end;
      BQI.InformationLevel := BatteryGranularityInformation;
      //Hersteller Datum:
      AkkuHerstellerDatum :='';
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), @BMD, SizeOf(BMD), lpBytesReturned, nil) then
        AkkuHerstellerDatum := IntToStr(BMD.Day) + '.' + IntToStr(BMD.Month) + '.' + IntToStr(BMD.Year);
      //-----------------
      BQI.InformationLevel := BatteryInformation;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), @BI, SizeOf(BI), lpBytesReturned, nil) then
      begin
        //Chemie:
        AkkuChemie := '';
        for i := 0 to 3 do
          AkkuChemie := AkkuChemie + Char(BI.Chemistry[i]);
        //-----------------
        //Technologie:
        case BI.Technology of
          0: AkkuTechnologie := 'Nicht Aufladbar';
          1: AkkuTechnologie := 'Aufladbar';
        end;
        //-----------------
        //Akku Kapazität insgesamt:
        AkkuKapazitätAngabe :=BI.DesignedCapacity;
        //Volle Kapazität:
        AkkuKapazitätVoll := BI.FullChargedCapacity;
        //Restzeit ermitteln:
        AkkuGesamtZeit:= round((BI.DesignedCapacity / BI.FullChargedCapacity)*60);
        AkkuRestZeit:= round(AktuelleKapazität * (AkkuGesamtZeit/60));
        AkkuRestZeit:= round( AkkuRestZeit * AkkuGesamtZeit / BI.DesignedCapacity);
        //Zykluszähler:
        AkkuLadeZyklen:= BI.CycleCount;
        //Alarm:
        AkkuAlarm1 := BI.DefaultAlert1;
        AkkuAlarm2 := BI.DefaultAlert2;
        //Kritische:
        AkkuKritisch := BI.CriticalBias;
        //Funktion:
        AkkuFunktion := '';
        if (BI.Capabilities and BATTERY_CAPACITY_RELATIVE) <> 0 then begin
          AkkuFunktion := 'Capacity Relative';
        end else if (BI.Capabilities and BATTERY_IS_SHORT_TERM) <> 0 then begin
          AkkuFunktion := 'Is Short Term';
        end else if (BI.Capabilities and BATTERY_SET_CHARGE_SUPPORTED) <> 0 then begin
          AkkuFunktion := 'Set Charge Supported';
        end else if (BI.Capabilities and BATTERY_SET_DISCHARGE_SUPPORTED) <> 0 then begin
          AkkuFunktion := 'Set Discharge Supported';
        end else if (BI.Capabilities and BATTERY_SYSTEM_BATTERY) <> 0 then begin
          AkkuFunktion := 'System Battery';
        end;
      end;
      BQI.InformationLevel := BatteryEstimatedTime;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), @i, 255, lpBytesReturned, nil) then
      begin
         if (i < 1000) and (i > 0) then begin
            AkkuRestZeit := i;
         end;
      end;
      //the battery's current temperature, in 10ths of a degree Kelvin
      //Round(Temperature/ 10 + 273.15)
      //Temperatur:
      BQI.InformationLevel := BatteryTemperature;
      AkkuTemperatur := 0;
      if DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, @BQI, SizeOf(BATTERY_QUERY_INFORMATION), @i, 255, lpBytesReturned, nil) then
      begin
        if i <> 0 then begin
          AkkuTemperatur := i;
        end;
      end;
    finally
      FreeMem(OutBuffer);
    end;
    CloseHandle(hBattery);
  end;
  If (AktuelleRate = 0) then begin
    AktuelleStromstaerke:=(round(AktuelleKapazität/AktuelleSpannung*1000));
  end else begin
    AktuelleStromstaerke:=(round(Abs(AktuelleRate)/AktuelleSpannung*1000));
  end;
  GetAccuStatus(false);
end;
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

end.

Im Aufrufformular:

Klasse hinzufügen:

Delphi-Quellcode:

{$R *.dfm}
var
  BatterieFunktionen : TBatterieFunktionen;

Klasse noch erstellen: z.B.: (FormCreate)
BatterieFunktionen:=TBatterieFunktionen.Create;

Klassen Instanz aktualisieren: z.B.: (Über einen Timer)
BatterieFunktionen.WerteAktualisieren(0); //(0)ist das Ausgewählte Akku 

anschließend die benötigten Werte auslesen: z.B.: ...
label1.Caption:=' Akku-Name : '+ BatterieFunktionen.AkkuName';
label2.Caption:=' Spannung : '+ IntToStr(BatterieFunktionen.AktuelleSpannung) + ' mV';

[mkinzler]

Hast du eine Frage? Oder ist das ein Vorschlag für die CodeLib?

[hathor]

Alles (?) eigener Code - sonst Quellenangabe sinnvoll...

Vorschlag: Textausgabe vereinheitlichen: entweder alles deutsch oder alles englisch!
Angabe der getesteten WINDOWS-Versionen.

[torsti.j]

Weis auch nicht mehr wo der Ursprung lag.
Hatte das Problem, dass nichts brauchbares zu diesem Thema im Netz zu finden war,
um die Volt (Spannung) des Akkus auszulesen.
Vor allem, die Beispiele im Netz die ich gefunden hatte erhöhten bei jedem Aufruf den Speicherbedarf.

Also hab ich eine Unit erstellt mit der man alle Batterie-infos auslesen kann.

Werde doch nicht der einzige sein, den das Interessiert. :)

[torsti.j]

Habs mit Delphi 2006 geschrieben und auf xp und win7 getestet.

Hier ist meine Akkuwache:

[hathor]

Irgendwie kommt mir das bekannt vor...
Da war die Spannung auch falsch.

Beim Ausschalten des Modems kommt die Meldung: SetClassInstallParams

[torsti.j]

Manche Geräte lassen sich nicht deaktivieren.
Das ist noch ne kleine Aufgabe für mich. Aber das gehört ja nicht zu diesem Beitrag.
;)

[torsti.j]

AktuelleKapazität muss AktuelleKapazitaet heisen!!!

[hathor]

Code teilweise von hier?
http://4coder.org/delphi-source-code....pas.html?text

[hathor]

http://4coder.org/delphi-source-code...ttery-info.zip