Ich glaube nicht das dass auf direktem Weg möglich ist, sonst würde es für die Beep Funktion wohl einen Parameter geben der Wahlweise die Ausgabe über Soundkarte und/oder über den internen Speaker erlaubt.
Versuche doch mal rauszubekommen ob man die beep-töne in eine midi umrechnen kann (müsste ja theoretisch gehen). Und die spielst du dann mit playsound ab.
wenns nicht geht bleibt immer noch die möglichkeit die Pieper mit dem micro aufzunehmen und als .wav speichern und abspielen.
in der Funktion selbst steht ein Sleep(500)
Ich war und bin mir immer noch nicht wirklich sicher wie ich das mit den Pausenzeiten in der Funktion regeln soll. immerhin muss eine Zeitdifferenz da sein. Aber du kannst gerne mal ein Sleep(1) draus machen oder ganz entfernen und sagen ob es besser ist. Immerhin müsste es ja schneller gehen wenn man direkt auf die Api zugreift.
Edit: Habs grade mal ausprobiert, sleep ganz weglassen geht nicht, dann ist die Zeitdifferenz 0 und es endet mit einem völlig unsinnigen wert für die Prozessorauslastung.
Seltsam, AutoIT kennt wohl keinen "Devided by Zero" Fehler
Naja Sleep(10) geht aber, und ich denke das sollte ausreichend schnell sein.
Danke 
ist auch schon als UDF Verpackt 
UDF aktualisiert.
Änderung:
_GetCPUUsage() jetzt Multiprozessorfähig
Hab mal eine Funktion geschrieben die ohne wmi auskommt.
Würde mich freuen wenn das mal jemand testen könnte und guckt ob die werte zumindest etwa hinkommen. Thx
;#####################################################################
;#
;# Funtion _GetCPUUsage()
;# Ermittelt die Auslastung der CPU, Multicore Kompatibel
;#
;# Rückgabewert: Array
;# Array[0] Anzahl der CPUs, Fehler wenn negativ
;# Array[n] Auslastung der n-ten CPU in Prozent
;#
;# Fehler: -1 Fehler beim 1. Dll Aufruf
;# -2 Fehler beim 2. Dll Aufruf
;# -3 Fehler beim 3. Dll Aufruf
;#
;# Autor: Bitboy
;#####################################################################
Func _GetCPUUsage()
Local Const $SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = 8
Local Const $SYSTEM_TIME_INFO = 3
Local Const $tagS_SPPI = "int64 IdleTime;int64 KernelTime;int64 UserTime;int64 DpcTime;int64 InterruptTime;long InterruptCount"
Local $CpuNum, $IdleOldArr[1],$IdleNewArr[1], $tmpStruct
Local $timediff = 0, $starttime = 0
Local $S_SYSTEM_TIME_INFORMATION, $S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
Local $RetArr[1]
Local $S_SYSTEM_INFO = DllStructCreate("ushort dwOemId;short wProcessorArchitecture;dword dwPageSize;ptr lpMinimumApplicationAddress;" & _
"ptr lpMaximumApplicationAddress;long_ptr dwActiveProcessorMask;dword dwNumberOfProcessors;dword dwProcessorType;dword dwAllocationGranularity;" & _
"short wProcessorLevel;short wProcessorRevision")
;Anzahl der CPUs bestimmen
$err = DllCall("Kernel32.dll", "none", "GetSystemInfo", "ptr",DllStructGetPtr($S_SYSTEM_INFO))
If @error Or Not IsArray($err) Then ;Fehler beim 1. Dll Aufruf
Return $RetArr[0] = -1
Else
$CpuNum = DllStructGetData($S_SYSTEM_INFO, "dwNumberOfProcessors")
ReDim $RetArr[$CpuNum+1]
$RetArr[0] = $CpuNum
EndIf
$S_SYSTEM_INFO = 0
While 1
;Erstellen der Struktur für die Prozessor Performance
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = DllStructCreate($tagS_SPPI)
;Größe Struktur um später vielfache (MultiCore) der Structur lesen zu können
$StructSize = DllStructGetSize($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
;Erstellen einer Pufferstruktur
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = DllStructCreate("byte puffer[" & $StructSize * $CpuNum & "]")
;Pointer zum wiederfinden
$pointer = DllStructGetPtr($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", _
"int", $SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, _
"ptr", DllStructGetPtr($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), _
"int", 0)
;Fehler beim 2. Dll Aufruf
If $err[0] Then
Return $RetArr[0] = -2
EndIf
;Struktur und Dll-Aufruf für Zeitmessung
Local $S_SYSTEM_TIME_INFORMATION = DllStructCreate("int64;int64;int64;uint;int")
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", _
"int", $SYSTEM_TIME_INFO, _
"ptr", DllStructGetPtr($S_SYSTEM_TIME_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_TIME_INFORMATION), _
"int", 0)
;Fehler beim 3. Dll Aufruf
If $err[0] Then
Return $RetArr[0] = -3
EndIf
If $starttime = 0 Then ;Startwerte Ermitteln
ReDim $IdleOldArr[$CpuNum]
;Start-Informationen Auslesen
For $i = 0 to $CpuNum -1
$tmpStruct = DllStructCreate($tagS_SPPI, $Pointer + $i*$StructSize)
$IdleOldArr[$i] = DllStructGetData($tmpStruct,"IdleTime")
Next
;Startzeit ermitteln
$starttime = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2)
;Verzögerung um einen Zeitunterschied sicher zu stellen
Sleep(500)
Else
ReDim $IdleNewArr[$CpuNum]
;Neue Informationen auslesen
For $i = 0 to $CpuNum -1
$tmpStruct = DllStructCreate($tagS_SPPI, $Pointer + $i*$StructSize)
$IdleNewArr[$i] = DllStructGetData($tmpStruct,"IdleTime")
Next
;Zeitdifferenze in 100 nanosekunden
$timediff = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2) - $starttime
;Auslastung errechnen
For $i=0 to $CpuNum -1
$RetArr[$i+1] = Round(100-(($IdleNewArr[$i] - $IdleOldArr[$i]) * 100 / $timediff))
Next
Return $RetArr
EndIf
;Speicher wieder frei geben
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = 0
$S_SYSTEM_TIME_INFORMATION = 0
$tmpStruct = 0
WEnd
EndFunc
Wollte mal fragen ob das generell möglich ist oder kann man nur form bezogen eine Zeichnung erstellen.
Also zum Beispiel bei einem Tab-Control auf jedem Tab ein eigenes Bild erstellen.
Eigentlich Schade dass die IDE nicht in Autoit gecoded wird sonst könnte jeder hier auch die ein oder andere Funktion besteuern.
Ich wünsch ihm trotzdem gutes gelingen 
Auf direktem Weg seh ich da keine Chancen, aber es müsste doch gehen die exe, die zu dem Fenter gehört herauszufinden. Dann hast du auch das ICON
kannst du mal nachsehen ob es den Schlüssel
HKEY_LOCAL_MACHINE\SYSTEM\ControlSet\Enum\USB\Vid_0a12&Pid_0001
bei dir gibt?und wenn ja schau mal ob in Unterverzeichnissen irgendetwas drin steht
Naja ich denk mir das so: Was im Gerätemanager steht, MUSS auch irgendwo in der Registry stehen. Deswegen wundert es mich das da keine veränderung festzustellen ist.
Du könntest dir auch die Ascii-Zahl für jeden einzelnen Buchstaben wiedergeben lassen und die mit der Funktion oben umrechnen.
$Num=Asc($Buchstabe)
Da gibts es einen Portscanner, musst das Script nur für deine Bedürfnisse anpassen:
http://www.autoitscript.com/forum/index.php?showtopic=50236&st=0
Wenn das FTP Programm eine Rückmeldung in die Konsole schreibt kannst du diese Fehlermeldung auslesen und daraufhin die schleife abbrechen. Stichwort: StdoutRead.
Da dürfte nur die Möglichkeit bleiben Word mit der Datei zu öffnen, alles zu markieren, kopieren und in deine Editbox einfügen. Sämtliche Formatierungen sind dann aber weg und Änderungen kannst du nicht zurückspeichern.
Den von dir genannten Reg-Schlüssel würde ich nicht nehmen da es zuviele Fehlerquellen gibt.
Ich würde eher
HKLM\SYSTEM\ControlSet001\Control\DeviceClasses\
benutzen.
Der gesamte Schlüssel für meinen USB-Stick sieht so aus:
HKLM\SYSTEM\ControlSet001\Control\DeviceClasses\{53f56307-b6bf-11d0-94f2-00a0c91efb8b}\##?#USBSTOR#Disk&Ven_Kingston&Prod_DT_HyperX&Rev_1.00#0018F30C6AF2SK88060A1199&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}\#\Control\Linked: 0x00000001
Soll nur eine bestimmte Hardware (könnte ja auch ein Bluetooth-STICK sein) ist der Weg der sicherste.
Man erfährt den genauen Schlüssel indem man Regshot benutzt.
Eine allgemeine Abfrage für jede Hardware sollte so auch möglich sein.
Soll es nur für USB-Laufwerke sein käme noch dieser Schlüssel in betracht:
HKLM\SYSTEM\ControlSet001\Services\USBSTOR\Enum\Count: 0x00000001
Hätte den Vorteil das es unabhängig von installierten Festplatten ist.
Hm, achso ist das.
Ich fürchte es ist vom Prinzip nicht dasselbe. (Sonst müsste es Änderungen in der Registry geben).
Wird das Gerät denn im Gerätemanager angezeigt oder nur in der Software für den Bluetooth Stick?
Wenns nur von der Software "erkannt" wird, welche Software ist es?
Edit:
Ist es denn das Einzigste Gerät was du über Bluetooth verbindest? Dann wüsst ich vllt einen Workaround
Eigentlich sollte regshot das hinbekommen.
Hast du die Schritte wirklich in der Reihenfolge ausgeführt:
1. Gerät entfernen
2. Regshot: 1. Schuss
3. Gerät anschließen (eventuell etwas warten)
4. Regshot: 2. Schuss
5. Regshot: Vergleichen
Hatte das so mal mit einem USB-Stick versucht und hat einwandfrei funktioniert.
Hab mal eine kleine UDF zusammengestellt die die Auslastung von CPU, Ram und Netwerk ermittelt.
Stichwörter für Forensuche: Prozessor, Prozessoren, Memory, Netzwerkauslastung, Usage
Update: 7.4.09
usage.au3 :
#include-once
;#####################################################################
;#
;# Funtion _GetCPUUsage()
;# Ermittelt die Auslastung der CPU, Multicore Kompatibel
;#
;# Rückgabewert: Array
;# Array[0] Anzahl der CPUs, Fehler wenn negativ
;# Array[n] Auslastung der n-ten CPU in Prozent
;#
;# Fehler: -1 Fehler beim 1. Dll Aufruf
;# -2 Fehler beim 2. Dll Aufruf
;# -3 Fehler beim 3. Dll Aufruf
;#
;# Autor: Bitboy
;#####################################################################
Func _GetCPUUsage()
Local Const $SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = 8
Local Const $SYSTEM_TIME_INFO = 3
Local Const $tagS_SPPI = "int64 IdleTime;int64 KernelTime;int64 UserTime;int64 DpcTime;int64 InterruptTime;long InterruptCount"
Local $CpuNum, $IdleOldArr[1],$IdleNewArr[1], $tmpStruct
Local $timediff = 0, $starttime = 0
Local $S_SYSTEM_TIME_INFORMATION, $S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
Local $RetArr[1]
Local $S_SYSTEM_INFO = DllStructCreate("ushort dwOemId;short wProcessorArchitecture;dword dwPageSize;ptr lpMinimumApplicationAddress;" & _
"ptr lpMaximumApplicationAddress;long_ptr dwActiveProcessorMask;dword dwNumberOfProcessors;dword dwProcessorType;dword dwAllocationGranularity;" & _
"short wProcessorLevel;short wProcessorRevision")
;Anzahl der CPUs bestimmen
$err = DllCall("Kernel32.dll", "none", "GetSystemInfo", "ptr",DllStructGetPtr($S_SYSTEM_INFO))
If @error Or Not IsArray($err) Then ;Fehler beim 1. Dll Aufruf
Return $RetArr[0] = -1
Else
$CpuNum = DllStructGetData($S_SYSTEM_INFO, "dwNumberOfProcessors")
ReDim $RetArr[$CpuNum+1]
$RetArr[0] = $CpuNum
EndIf
$S_SYSTEM_INFO = 0
While 1
;Erstellen der Struktur für die Prozessor Performance
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = DllStructCreate($tagS_SPPI)
;Größe Struktur um später vielfache (MultiCore) der Structur lesen zu können
$StructSize = DllStructGetSize($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
;Erstellen einer Pufferstruktur
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = DllStructCreate("byte puffer[" & $StructSize * $CpuNum & "]")
;Pointer zum wiederfinden
$pointer = DllStructGetPtr($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", _
"int", $SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, _
"ptr", DllStructGetPtr($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), _
"int", 0)
;Fehler beim 2. Dll Aufruf
If $err[0] Then
Return $RetArr[0] = -2
EndIf
;Struktur und Dll-Aufruf für Zeitmessung
Local $S_SYSTEM_TIME_INFORMATION = DllStructCreate("int64;int64;int64;uint;int")
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", _
"int", $SYSTEM_TIME_INFO, _
"ptr", DllStructGetPtr($S_SYSTEM_TIME_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_TIME_INFORMATION), _
"int", 0)
;Fehler beim 3. Dll Aufruf
If $err[0] Then
Return $RetArr[0] = -3
EndIf
If $starttime = 0 Then ;Startwerte Ermitteln
ReDim $IdleOldArr[$CpuNum]
;Start-Informationen Auslesen
For $i = 0 to $CpuNum -1
$tmpStruct = DllStructCreate($tagS_SPPI, $Pointer + $i*$StructSize)
$IdleOldArr[$i] = DllStructGetData($tmpStruct,"IdleTime")
Next
;Startzeit ermitteln
$starttime = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2)
;Verzögerung um einen Zeitunterschied sicher zu stellen
Sleep(100)
Else
ReDim $IdleNewArr[$CpuNum]
;Neue Informationen auslesen
For $i = 0 to $CpuNum -1
$tmpStruct = DllStructCreate($tagS_SPPI, $Pointer + $i*$StructSize)
$IdleNewArr[$i] = DllStructGetData($tmpStruct,"IdleTime")
Next
;Zeitdifferenze in 100 nanosekunden
$timediff = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2) - $starttime
;Auslastung errechnen
For $i=0 to $CpuNum -1
$RetArr[$i+1] = Round(100-(($IdleNewArr[$i] - $IdleOldArr[$i]) * 100 / $timediff))
Next
Return $RetArr
EndIf
;Speicher wieder frei geben
$S_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = 0
$S_SYSTEM_TIME_INFORMATION = 0
$tmpStruct = 0
WEnd
EndFunc
;#####################################################################
;#
;# Funtion _GetCPUUsageOld()
;# Ermittelt die Auslastung der CPU (Wie im Taskmanager angezeigt)
;#
;# Rückgabewert: Auslastung der CPU in Prozent, Fehler wenn negativ
;# Fehler: -1 Fehler beim 1. Dll Aufruf
;# -2 Fehler beim 2. Dll Aufruf
;# -3 Fehler beim 3. Dll Aufruf
;#
;# Hinweis: Mit zukünftigen Windowsversion eventuell nicht kompatibel,
;# Ungenau bei Multi-Prozessorsystemen
;#
;# Autor: ???
;#####################################################################
Func _GetCPUUsageOld()
Local Const $SYSTEM_BASIC_INFO = 0
Local Const $SYSTEM_PERFORMANCE_INFO = 2
Local Const $SYSTEM_TIME_INFO = 3
Local $idletimeold = 0,$idletimediff=0, $idle
Local $starttime = 0, $timediff = 0, $CPUCount=0
;Struktur für Basis Informationen
$S_SYSTEM_BASIC_INFORMATION = DllStructCreate("int;uint;uint;uint;uint;uint;uint;ptr;ptr;uint;byte;byte;short")
$err = DllCall("ntdll.dll", _
"int", "NtQuerySystemInformation", _
"int", $SYSTEM_BASIC_INFO, _
"ptr", DllStructGetPtr($S_SYSTEM_BASIC_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_BASIC_INFORMATION), _
"int", 0)
If $err[0] Then Return -1
$CPUCount = DllStructGetData($S_SYSTEM_BASIC_INFORMATION, 11)
$S_SYSTEM_BASIC_INFORMATION = 0
While 1
;Struktur für CPU Zeit
Local $S_SYSTEM_PERFORMANCE_INFORMATION = DllStructCreate("int64;int[76]")
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", "int", $SYSTEM_PERFORMANCE_INFO, _
"ptr", DllStructGetPtr($S_SYSTEM_PERFORMANCE_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_PERFORMANCE_INFORMATION), _
"int", 0)
If $err[0] Then Return -2
;Struktur für Zeitmessung
Local $S_SYSTEM_TIME_INFORMATION = DllStructCreate("int64;int64;int64;uint;int")
$err = DllCall("ntdll.dll", "int", "NtQuerySystemInformation", _
"int", $SYSTEM_TIME_INFO, _
"ptr", DllStructGetPtr($S_SYSTEM_TIME_INFORMATION), _
"int", DllStructGetSize($S_SYSTEM_TIME_INFORMATION), _
"int", 0)
If $err[0] Then Return -3
;Startwerte ermitteln
If $starttime = 0 Then
$idletimeold = DllStructGetData($S_SYSTEM_PERFORMANCE_INFORMATION, 1)
$starttime = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2)
Sleep(100)
Else
; "Aktuelle" Werte ermitteln
$idletimediff = DllStructGetData($S_SYSTEM_PERFORMANCE_INFORMATION, 1) - $idletimeold
$timediff = DllStructGetData($S_SYSTEM_TIME_INFORMATION, 2) - $starttime
;Berechnung
$idle = Round(100.0 - ($idletimediff * 100.0 / $timediff)/$CPUCount,0)
Return $idle
EndIf
$S_SYSTEM_PERFORMANCE_INFORMATION = 0
$S_SYSTEM_TIME_INFORMATION = 0
WEnd
EndFunc
;####################################################
;#
;# Funtion _GetMemUsage()
;# Ermittelt die Ram-Auslastung in Prozent
;#
;# Rückgabewert: Array [0] Physikalischer Speicher
;# [1] Auslagerungsdatei
;# [2] Virtueller Speicher
;#
;# Autor: Bitboy
;####################################################
Func _GetMemUsage()
Local $memstat, $retArr[3]
$memstat = MemGetStats ()
$retArr[0] = $memstat[0] ;Physikalischer Speicher
$retArr[1] = Round(100 - ($memstat[4] / $memstat[3] * 100)) ;Auslagerungsdatei
$retArr[2] = Round(100 - ($memstat[6] / $memstat[5] * 100)) ;Virtueller Speicher
Return $retArr
EndFunc
;####################################################
;#
;# Funtion _GetNetUsage()
;# Ermittelt die Auslastung aller _Ethernet_ Adapter
;#
;# Rückgabewert: Array [n][0] Name des Adapters
;# [n][1] Auslastung in Prozent
;#
;# Autor: Bitboy
;####################################################
Func _GetNetUsage()
Local $netarrold[1], $netarr[1], $tmparr, $retarr[1]
Local $AdapterNum, $i, $x, $timediff,$netcounter=0, $InOutBytes
For $i =1 to 2
$tmparr = _GetNetAdapterInfo($AdapterNum)
If $i = 1 Then
ReDim $netarrold[$AdapterNum][2]
$timediff = TimerInit()
For $x = 0 to $AdapterNum -1
If $tmparr[$x][2] = 6 Then ;Ethernet Adapter
;InOctets
$netarrold[$netcounter][0] = $tmparr[$x][10]
;OutOctets
$netarrold[$netcounter][1] = $tmparr[$x][16]
$netcounter = $netcounter + 1
EndIf
Next
Sleep(100)
Else
$timediff = TimerDiff($timediff)
ReDim $retarr[$netcounter][2]
$netcounter = 0
For $x = 0 to $AdapterNum -1
If $tmparr[$x][2] = 6 Then ;Ethernet Adapter
;Adapternamen speichern
$retarr[$netcounter][0] = $tmparr[$x][23]
;Auslastung = ((InOctets + Outoctets) - (InOctetsOld + OutoctetsOld) / timediff/1000) / Netspeed * 8 * 100
$InOutBytes = ($tmparr[$x][10] + $tmparr[$x][16])-($netarrold[$netcounter][0] + $netarrold[$netcounter][1])
$retarr[$netcounter][1] = Round(($InOutBytes / ($timediff /1000)) / $tmparr[$x][4] * 8 *100)
$netcounter = $netcounter + 1
EndIf
Next
Return $retarr
EndIf
Next
EndFunc
;################################################################################################################
;#
;# Funktion _GetNetAdapterInfo (ByRef $AdapterNum)
;# Interne Funktion zum Ermitteln von Netzwerkadapter Informationen
;#
;# Rückgabewerte: Array [n][0] wszName, meist (immer?) leer
;# Array [n][1] dwIndex, Indexnummer des Adapters
;# Array [n][2] dwType, Typ des Adapters, Siehe Konstanten
;# Array [n][3] dwMTU, Maximale Paketgröße
;# Array [n][4] dwSpeed, Geschwindigkeit in Bit/Sekunde
;# Array [n][5] dwPhysAddrLen, Länge der Physikalischen (MAC) Adresse (Immer 
;# Array [n][6] bPhysAddr, Physikalische (MAC) Adresse
;# Array [n][7] dwAdminStatus, Verbindung aktiviert? 1 oder 0
;# Array [n][8] dwOperStatus,???
;# Array [n][9] dwLastChange, Letzte Veränderung seit Systemstart in hunderstel-sekunden
;# Array [n][10] dwInOctets, Empfangene Oktetts (1 Oktett = 8 Bit = 1 Byte)
;# Array [n][11] dwInUcastPkts, Empfangene Unicast Pakete
;# Array [n][12] dwInNUcastPkts, Empfangene Non-Unicast Pakete
;# Array [n][13] dwInDiscards, Empfangene und verworfene Pakete
;# Array [n][14] dwInErrors, Empfangene und verworfene fehlerhafte Pakete
;# Array [n][15] dwInUnknownProtos, Empfangene und verworfene Pakete wegen unbekanntem Protokoll
;# Array [n][16] dwOutOctets, Gesendete Oktetts (1 Oktett = 8 Bit = 1 Byte)
;# Array [n][17] dwOutUcastPkts, Gesendete Unicast Pakete
;# Array [n][18] dwOutNUcastPkts, Gesendete Non-Unicast Pakete
;# Array [n][19] dwOutDiscards, Gesendete und verworfene Pakete
;# Array [n][20] dwOutErrors, Gesendete und verworfene fehlerhafte Pakete
;# Array [n][21] dwOutQLen, Übertragungswarteschlange (derzeit unbenutzt)
;# Array [n][22] dwDescrLen, Zeichenlänge des Adapternamens (Konstant 256)
;# Array [n][23] bDescr, Adaptername
;# $AdapterNum enthält die Anzahl der Adapter [n]
;#
;# Autor: Progandy (autoit.de), Bitboy
;################################################################################################################
Func _GetNetAdapterInfo(ByRef $AdapterNum)
;Konstantendeklaration
;Netzwerk Adapter Typen
Local Const $MIB_IF_TYPE_OTHER = 1 ;Some other type of network interface.
Local Const $MIB_IF_TYPE_ETHERNET = 6 ;An Ethernet network interface.
Local Const $MIB_IF_TYPE_TOKENRING = 9 ;A token ring network interface.
Local Const $MIB_IF_TYPE_PPP = 23 ;A PPP network interface.
Local Const $MIB_IF_TYPE_LOOPBACK = 24 ;A software loopback network interface.
Local Const $MIB_IF_TYPE_ATM = 37 ;An ATM network interface.
Local Const $MIB_IF_TYPE_IEEE80211 = 73 ;An IEEE 802.11 wireless network interface.
Local Const $MIB_IF_TYPE_TUNNEL = 131 ;A tunnel type encapsulation network interface.
Local Const $MIB_IF_TYPE_IEEE1394 = 144 ;An IEEE 1394 (Firewire) high performance serial bus network interface.
Local Const $MAX_INTERFACE_NAME_LEN = 256
Local Const $MAXLEN_IFDESCR = 256
Local Const $MAXLEN_PHYSADDR = 8
;Struktur für Tabellenzeile
Local Const $tagMIB_IFROW = _
"WCHAR wszName[" & $MAX_INTERFACE_NAME_LEN & "]; " & _
"DWORD dwIndex;" & _
"DWORD dwType;" & _
"DWORD dwMtu;" & _
"DWORD dwSpeed;" & _
"DWORD dwPhysAddrLen;" & _
"BYTE bPhysAddr[" & $MAXLEN_PHYSADDR & "];" & _
"DWORD dwAdminStatus;" & _
"DWORD dwOperStatus;" & _
"DWORD dwLastChange;" & _
"DWORD dwInOctets;" & _
"DWORD dwInUcastPkts;" & _
"DWORD dwInNUcastPkts;" & _
"DWORD dwInDiscards;" & _
"DWORD dwInErrors;" & _
"DWORD dwInUnknownProtos;" & _
"DWORD dwOutOctets;" & _
"DWORD dwOutUcastPkts;" & _
"DWORD dwOutNUcastPkts;" & _
"DWORD dwOutDiscards;" & _
"DWORD dwOutErrors;" & _
"DWORD dwOutQLen;" & _
"DWORD dwDescrLen;" & _
"CHAR bDescr[" & $MAXLEN_IFDESCR & "];"
;Deklaration der Struktur MIB_IFTABLE
Local Const $tagMIB_IFTABLE_HEADER = "DWORD dwNumEntries;"
;Variablendeklaration
Local $puffersize = 0, $StructSize = 0, $i=0, $j=0, $AdapterCount = 0
Local $puffer, $Pointer, $retArr[1][1]
Local $MIB_IFROW = DllStructCreate($tagMIB_IFROW)
;Erster Aufruf (wird fehlschlagen) liefert dabei aber die benötigte Puffergröße
Local $err = DllCall("Iphlpapi.dll", "dword","GetIfTable","ptr", 0, "ulong*", 0,"long",1)
If Not @error Then
If $err[0] = 122 Then ;Fehler: Puffer zu klein
$puffersize = $err[2]
EndIf
EndIf
;Erstellen der Struktur MIB_IFTABLE mit passender Puffergröße
Local $MIB_IFTABLE = DllStructCreate($tagMIB_IFTABLE_HEADER & "byte puffer[" & $puffersize &"]")
;Zweiter Aufruf
$err = DllCall("Iphlpapi.dll", "dword","GetIfTable","ptr", DllStructGetPtr($MIB_IFTABLE), "ulong*", DllStructGetSize($MIB_IFTABLE),"long",1)
;Größe der Struktur und die Anzahl der Adapter speichern
$AdapterCount = DllStructGetData($MIB_IFTABLE, "dwNumEntries")
$AdapterNum = $AdapterCount
$StructSize = DllStructGetSize($MIB_IFROW)
$Pointer = DllStructGetPtr($MIB_IFTABLE, "puffer")
ReDim $retArr[$AdapterCount][24]
For $i = 0 To $AdapterCount-1
$MIB_IFROW = DllStructCreate($tagMIB_IFROW, $Pointer + $i*$StructSize)
For $j = 0 To 23
If $j = 6 Then
$retArr[$i][$j] = StringMid(DllStructGetData($MIB_IFROW, $j+1),3,12)
Else
$retArr[$i][$j] = DllStructGetData($MIB_IFROW, $j+1)
EndIf
Next
Next
$MIB_IFROW = 0
$MIB_IFTABLE = 0
Return $retArr
EndFunc
#cs
;Folgender Code dient nur zum Testen und kann gelöscht werden
#include<Array.au3>
Local $Count
;CPU-Auslastung
$test = _GetCPUUsage()
_ArrayDisplay ($test)
;Alte CPU-Auslastung
MsgBox(0,"CPU Auslastung", _GetCPUUsageOld()&"%")
;Ram-Auslastung
$array = _GetMemUsage()
_ArrayDisplay($array)
;Netzwerkauslastung
$array = _GetNetUsage()
_ArrayDisplay($array)
;Netwerkinfo
$array = _GetNetAdapterInfo($Count)
; Namen zur Info einfügen
ReDim $array[$Count+1][UBound($array,2)]
$array[$Count][0] = "wszName"
$array[$Count][1] = "dwIndex"
$array[$Count][2] = "dwType"
$array[$Count][3] = "dwMtu"
$array[$Count][4] = "dwSpeed"
$array[$Count][5] = "dwPhysAddrLen"
$array[$Count][6] = "bPhysAddr"
$array[$Count][7] = "dwAdminStatus"
$array[$Count][8] = "dwOperStatus"
$array[$Count][9] = "dwLastChange"
$array[$Count][10] = "dwInOctets"
$array[$Count][11] = "dwInUcastPkts"
$array[$Count][12] = "dwInNUcastPkts"
$array[$Count][13] = "dwInDiscards"
$array[$Count][14] = "dwInErrors"
$array[$Count][15] = "dwInUnknownProtos"
$array[$Count][16] = "dwOutOctets"
$array[$Count][17] = "dwOutUcastPkts"
$array[$Count][18] = "dwOutNUcastPkts"
$array[$Count][19] = "dwOutDiscards"
$array[$Count][20] = "dwOutErrors"
$array[$Count][21] = "dwOutQLen"
$array[$Count][22] = "dwDescrLen"
$array[$Count][23] = "bDescr"
_ArrayDisplay($array)
[/autoit] [autoit][/autoit] [autoit]#ce
[/autoit] [autoit][/autoit] [autoit][/autoit]Edit: Jetzt MIT Rahmen 
Edit: Tippfehler korrigiert.
Hinweis: Bei einem Dualcore geht die Auslastung nicht über 50 %, die Gesamtauslastung wird nämlich durch die Anzahl der Prozessoren gerechnet. Quadcore ist ungetestet.
Klasse vielen Dank, hatte die Hoffnung schon fast aufgegeben das es möglich ist, auf der anderen Seite hab ich im englischen Forum einen Beitrag von dir gesehen wo du etwas ähnliches beschreibst (Hab ich allerdings auf Anhieb auch nicht verstanden 
)
Eine kleine Verbesserung hab ich noch:
aus "BYTE bDescr[" & $MAXLEN_IFDESCR & "];"
"CHAR bDescr[" & $MAXLEN_IFDESCR & "];" dann stehen die Beschreibungen bereits richtig im Array.
Werde es mir morgen nochmal in Ruhe ansehen und versuchen zu verstehen, ich glaub heute hab ich nicht mehr den Kopf frei dafür.
Nochmal danke!
Aus der Hilfe-Datei
The source path of the file to compile. This must be a literal string; it cannot be a variable. It can be a relative path (using .\ or ..\ in the path).
kurz: dein $helpdir muss weg, kannst aber mal versuchen es als const zu deklarieren, vllt gehts dann.
Soweit bin ich schon mal, Die Informationen der Netzwerkkarten stehen in dem Puffer drin, zu sehen ist das in der Datei die angelegt wird.
Dort sind zumindest die Namen der Karten erkennbar.
Wie schaffe ich es jetzt jedoch die informationen in die Struktur zu packen? und auszulesen.
Das mit dem RTLMoveMemory habe ich aus einem Tipp von ActiveVB, jedoch lässt es sich nicht so einfach umschreiben.
Helfen würde es wohl auch schon wenn ich wüsste wie ich strukturen verschachtel.
Func _GetNetUsage()
;Netzwerk Adapter Typen
Const $MIB_IF_TYPE_OTHER = 1 ;Some other type of network interface.
Const $MIB_IF_TYPE_ETHERNET = 6 ;An Ethernet network interface.
Const $MIB_IF_TYPE_TOKENRING = 9 ;A token ring network interface.
Const $MIB_IF_TYPE_PPP = 23 ;A PPP network interface.
Const $MIB_IF_TYPE_LOOPBACK = 24 ;A software loopback network interface.
Const $MIB_IF_TYPE_ATM = 37 ;An ATM network interface.
Const $MIB_IF_TYPE_IEEE80211 = 73 ;An IEEE 802.11 wireless network interface.
Const $MIB_IF_TYPE_TUNNEL = 131 ;A tunnel type encapsulation network interface.
Const $MIB_IF_TYPE_IEEE1394 = 144 ;An IEEE 1394 (Firewire) high performance serial bus network interface.
;Variablendeklaration
Dim $puffersize, $StructSize, $AdapterCount
Dim $puffer
;Erstellen der Struktur MIB_IFROW
$str = "byte wszName[510];long dwIndex;long dwtype;long dwMTU;long dwSpeed;long dwPhysAddrLen;byte bPhysAddr[7];long dwAdminStatus;long dwOperStatus;long dwLastChange;"
$str = $str & "long dwInOctets;long dwInUcastPkts;long dwInNUcastPkts;long dwInDiscards;long dwInErrors;long dwInUnknownProtos;long dwOutOctets;long dwOutUcastPkts;"
$str = $str & "long dwOutNUcastPkts;long dwOutDiscards;long dwOutErrors;long dwOutQLen;long dwDescrLen;byte bDescr[255]"
$MIB_IFROW = DllStructCreate($str)
;Erstellen der Struktur MIB_IFTABLE
$MIB_IFTABLE = DllStructCreate("long dwNumEntries;")
;Erster Aufruf (wird fehlschlagen) liefert dabei aber die benötigte Puffergröße
$err = DllCall("Iphlpapi.dll", "dword","GetIfTable","ptr", DllStructGetPtr($MIB_IFTABLE), "long*", DllStructGetSize($MIB_IFTABLE),"long",1)
;Puffergröße bestimmen
If IsArray($err) Then
If $err[0] = 122 Then ;Fehler: Puffer zu klein
$puffersize = $err[2]
EndIf
EndIf
;Erstellen der Struktur MIB_IFTABLE mit passender Puffergröße
$MIB_IFTABLE = 0
$MIB_IFTABLE = DllStructCreate("long dwNumEntries;byte puffer[" & $puffersize &"]")
;Zweiter Aufruf
$err = DllCall("Iphlpapi.dll", "dword","GetIfTable","ptr", DllStructGetPtr($MIB_IFTABLE), "long*", DllStructGetSize($MIB_IFTABLE),"long",1)
;Größe der Struktur und die Anzahl der Adapter speichern
$StructSize = DllStructGetSize($MIB_IFROW)
$AdapterCount = DllStructGetData($MIB_IFTABLE, "dwNumEntries")
;Testdatei schreiben
$a=FileOpen("C:\test.txt",2)
FileWrite($a,(DllStructGetData($MIB_IFTABLE, "puffer")))
FileClose($a)
$puffer = Stringtoasciiarray(DllStructGetData($MIB_IFTABLE, "puffer"))
[/autoit] [autoit][/autoit] [autoit]$MIB_IFTABLE = 0
[/autoit] [autoit][/autoit] [autoit]For $i = 1 to $AdapterCount
$err = DllCall("kernel32", "none","RtlMoveMemory","ptr", DllStructGetPtr($MIB_IFROW), "byte*", Ptr($puffer[4+($i - 1) * $StructSize]),"ulong",$StructSize)
MsgBox(0,"bPhysAddr",DllStructGetData($MIB_IFROW, "bPhysAddr"))
Next
EndFunc
[/autoit] [autoit][/autoit] [autoit]_GetNetUsage()
[/autoit]
