USB CDC virtueller COM-Port

[labtechmw]

Hallo,
Folgendes Problem: Ich muss mehrere gleiche Peripheriegeräte über USB auslesen, d.h., es sind mehrere Geräte gleichzeitig am PC, die ich einzeln mittels eines gemeinsamen Programms öffnen kann, um Daten auszutauschen. Mittels Treiberinstallation werden den Geräten jeweils individuelle COM-Ports zugewiesen, so kann also die Auswahl erfolgen. Nun mein Problem:
*** Wie kann ich mittels Delphi eine Programmsequenz erstellen, mit der ich, wie im Gerätemanager, die einzelnen aktiven COM-Ports ermitteln kann.
Technische Basis: WIN 7/64 und höher.
Sollte jemand sich schon einmal mit einem ähnlichen Problem herumgeschlagen und eine Lösung gefunden haben, wäre ich über Infos sehr dankbar.

[Der schöne Günther]

Hallo und Herzlich Willkommen in den Heiligen Hallen des Wissens und des Wahnsinns :roteyes:

Was ist für dich ein "aktiver Comport"? Ports die da sind und die man aufmachen könnte? Wenn ja, dann schau doch einfach in die Registry unter

Delphi-Quellcode:

HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM

.

Ob der Port nicht schon von einer anderen Anwendung belegt ist findet man erst heraus wenn man mit

Delphi-Quellcode:

CreateFile(..)

versucht ihn zu öffnen und es schlägt fehl...

Ansonsten kannst du auch einfach im Forum suchen, z.B. nach "com ports finden". Dann kommt z.B. so etwas heraus:
http://www.delphipraxis.net/118592-c...-auslesen.html

[Dalai]

How to enumerate hardware devices by using SetupDi calls

Stichworte SetupDiGetClassDevs, SetupDiEnumDeviceInfo, CM_Get_DevNode_Status und einige mehr. Ist nicht ganz einfach, da die Doku teilweise echt dürftig ist oder die Funktionen nicht ganz so funktionieren wie beschrieben. Aber machbar ist es - und definitiv nicht so aufwendig wie die Ermittlung aller Geräte, denn du brauchst ja nur eine Gerätekategorie.

MfG Dalai

[labtechmw]

Hallo
und herzlichen Dank für die freundliche Aufnahme und eure Hinweise.
Hab daraufhin schon Einiges gefunden, was ich erstmal ordnen und dann ausprobieren werde. Ich bin hoffnungsvoll:idea:

MfG
labtechmw

[4dk2]

Die CPort-Komponenten könnten dir auch vielleicht helfen:
https://sourceforge.net/projects/comport/

Können alle Comports vom PC auslesen, und dann kannste damit auch noch einfach (ohne eigenes createfile usw. ;) ) den comport testen.

Delphi-Quellcode:

var ls:TStringList;
  I: Integer;
  sCur:String;
begin
  ls:=TStringList.Create;
  try
    EnumComPorts(ls);
    for I := 0 to ls.count-1 do
    begin
      try
        sCur:=trim(ls.Strings[i]);//die enum Funktion füllt rechts mit char(0), zumindest bei mir XD...
        comport1.Port:=ls.Strings[i];
        comport1.Open;
        if ComPort1.Connected then
          Memo1.Lines.Add(sCur+' geht')
        else
          Memo1.Lines.Add(sCur+' ?geht nicht?');
      except on exception do {order auch die passendere}
        Memo1.Lines.Add(sCur+' geht nicht')
      end;
    end;
  finally
    ls.free;
  end;
end;

=
CNCA0 geht
CNCB0 geht
COM2 geht nicht
COM7 geht

Die Cport macht nichts anderes als die Vorredner schon gesagt haben, in der Registry Ports auslesen, und Comport1.Open() macht irgendwo dann auch ein CreateFile()

Aber ist für den Anfang evtl. leicheter ;)

[v2afrank]

Ich benuztze ganz gerne diese Unit. Kommt so nicht von mir. Ich meine sogar von hier aus der DP

Delphi-Quellcode:

 unit Unitcomlister;

interface
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, JwaWinType, SetupApi, Cfg, CfgMgr32, StdCtrls;
var
 Portliste:TStringlist;
procedure FindComports(var Astringlist:TStringlist;AuchVirtuell:Boolean;Bis:Integer);
implementation
 // Delphi wrapper for CM_Get_Device_ID 

function GetDeviceID(Inst: DEVINST): string; 
var 
  Buffer: PTSTR; 
  Size: ULONG; 
begin 
  CM_Get_Device_ID_Size(Size, Inst, 0); 
  // Required! See DDK help for CM_Get_Device_ID 
  Inc(Size); 
  Buffer := AllocMem(Size * SizeOf(TCHAR)); 
  CM_Get_Device_ID(Inst, Buffer, Size, 0); 
  Result := Buffer; 
  FreeMem(Buffer); 
end; 

// Delphi wrapper for SetupDiGetDeviceRegistryProperty

function GetRegistryPropertyString(PnPHandle: HDEVINFO; const DevData: TSPDevInfoData; Prop: DWORD): string;
var
  BytesReturned: DWORD;
  RegDataType: DWORD;
  Buffer: array [0..1023] of TCHAR;
begin
  BytesReturned := 0;
  RegDataType := 0;
  Buffer[0] := #0;
  SetupDiGetDeviceRegistryProperty(PnPHandle, DevData, Prop,
    RegDataType, PByte(@Buffer[0]), SizeOf(Buffer), BytesReturned);
  Result := Buffer;
end;

function ExtractBus(DeviceID: string): string;
begin
  Result := Copy(DeviceID, 1, Pos('\', DeviceID) - 1);
end;



procedure FindComports(var Astringlist:TStringlist);
const
  GUID_DEVINTERFACE_COMPORT: TGUID                = '{86e0d1e0-8089-11d0-9ce4-08003e301f73}';
  GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR: TGUID = '{4D36E978-E325-11CE-BFC1-08002BE10318}';
var
  PnPHandle: HDEVINFO;
  DevData: TSPDevInfoData;
  DeviceInterfaceData: TSPDeviceInterfaceData;
  FunctionClassDeviceData: PSPDeviceInterfaceDetailData;
  Success: LongBool;
  Devn: Integer;
  BytesReturned: DWORD;
  SerialGUID: TGUID;
  Inst: DEVINST;
  RegKey: HKEY;
  RegBuffer: array [0..1023] of Char;
  RegSize, RegType: DWORD;
  FriendlyName: string;
  PortName: string;
  DeviceDescription: string;
  Bus: string;

  TestHandle : integer;
  i:integer;
begin


  // these API conversions are loaded dynamically by default

  LoadSetupApi;
  LoadConfigManagerApi;
  // enumerate all serial devices (COM port devices)
    SerialGUID := GUID_DEVINTERFACE_COMPORT; // GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR;
  PnPHandle := SetupDiGetClassDevs(@SerialGUID, nil, 0, DIGCF_PRESENT or DIGCF_DEVICEINTERFACE);
  if PnPHandle = Pointer(INVALID_HANDLE_VALUE) then
    Exit;
  Devn := 0;
  repeat
    DeviceInterfaceData.cbSize := SizeOf(TSPDeviceInterfaceData);
    Success := SetupDiEnumDeviceInterfaces(PnPHandle, nil, SerialGUID, Devn, DeviceInterfaceData);
    if Success then
    begin
      DevData.cbSize := SizeOf(DevData);
      BytesReturned := 0;
      // get size required for call
      SetupDiGetDeviceInterfaceDetail(PnPHandle, @DeviceInterfaceData, nil, 0, BytesReturned, @DevData);
      if (BytesReturned <> 0) and (GetLastError = ERROR_INSUFFICIENT_BUFFER) then
      begin
        // allocate buffer and initialize it for call
        FunctionClassDeviceData := AllocMem(BytesReturned); 
        FunctionClassDeviceData.cbSize := SizeOf(TSPDeviceInterfaceDetailData); 

        if SetupDiGetDeviceInterfaceDetail(PnPHandle, @DeviceInterfaceData,
          FunctionClassDeviceData, BytesReturned, BytesReturned, @DevData) then
        begin 
          // gives the friendly name of the device as shown in Device Manager 
          FriendlyName := GetRegistryPropertyString(PnPHandle, DevData, SPDRP_FRIENDLYNAME);
          // gives a device description
          DeviceDescription := GetRegistryPropertyString(PnPHandle, DevData, SPDRP_DEVICEDESC);
          // now try to get the assigned COM port name 
          RegKey := SetupDiOpenDevRegKey(PnPHandle, DevData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ); 
          RegType := REG_SZ; 
          RegSize := SizeOf(RegBuffer); 
          RegQueryValueEx(RegKey, 'PortName', nil, @RegType, @RegBuffer[0], @RegSize); 
          RegCloseKey(RegKey); 
          PortName := RegBuffer; 
          Inst := DevData.DevInst;
          CM_Get_Parent(Inst, Inst, 0);
          Bus := ExtractBus(GetDeviceID(Inst));
          Astringlist.Add(PortName + ' (' + DeviceDescription + ', ' + Bus+')');
        end;
        FreeMem(FunctionClassDeviceData);
      end;
    end;
    Inc(Devn);
  until not Success;
  SetupDiDestroyDeviceInfoList(PnPHandle);
  for I := 0 to Astringlist.Count - 1 do
   Portliste.Add(Astringlist[i]);

  // unload API conversions
  UnloadSetupApi;
  UnloadConfigManagerApi;

end;
initialization
 Portliste:=TStringlist.Create;
finalization
 portliste.Free;
end.