USB Port abfragen mit Delphi?

[Daniel Schuhmann]

Wie schon gesagt: USB ist für dich gestorben, das Ding meldet sich als virtueller COM-Port am System an (der taucht auf im Gerätemanager auf). Die eigentliche Kommunikation erfolgt zwar über den USB, aber der wird vor Dir vollkommen verborgen. Die Suche sollte also in Richtung "COM-Port mit Delphi benutzen" gehen.

[HorstBS]

Hmm danke jetzt hab ich zwar neue Probleme aber wenigstens such ich jetzt nen Stueck in die richtige Richtung..Also thx fuer die Hilfe!

[daisychain]

Hallo,
auch ich bin ein Anfänger.
Habe ähnliche Probleme gehabt.

Ich tippe dir hier ein paar Zeilen ab um den Unterschied zwischen C++ und delphi
zu veranschaulichen.
(nicht vollständig)

{---------------------------------Delphi-------------------------------------------------------------}


In diesem Anwendungsbeispiel werden die Arbeitsweisen und die Funktionen der K8055.DLL erklärt.
Auch werden die 2 wichtigsten DLL -Signale: OpenDevice und CloseDevice verdeutlicht.

Delphi-Quellcode:

unit xy;



interface

uses
  Windows,  Messages, SysUtils,  Classes,  Graphics, Controls,  Forms,  Dialogs,
   StdCtrls,  ExtCtrls, ComCtrls;
type
   TForm1 = class(TForm)
      GroupBox1:  TGroupBox;
     SK6: TCheckBox;
      SK5: TCheckBox;
      Button1: TButton;
     Label1:  TLabel;
    procedure  FormClose(Sender:  TObject;   var  Action:  TCloseAction);
     procedure   Button1Click(Sender:  TObject);
  private
    {  Private  declarations }
  public
    {  Public declarations  }
  end;

var
   Form1:  TForm1;
   timed:boolean;

implementation

{$R  *.DFM}

function  OpenDevice(CardAddress:  Longint):  Longint;   stdcall; extern al 'K8055d.dll ';
procedure  CloseDevice;  std call; external 'K8 055d.dll';
function   ReadAnalogChannel(Channel:   Longint):Longint;   stdcall; ext ernal 'K8055d.d ll';
procedure  ReadAllAnalog(va r  Data1, Data2:  Longint);  stdcall; exte rnal 'K8055d.d ll';
procedure  OutputAnalogChannel(Channel:  Longint;  Data:  Longint);  std call; external
'K 8055d.dll';
procedure  OutputAllAnalog(Data1:  Longint;  Data2:  Longint);  std call; external 'K 8055d.dll';
procedure   ClearAnalogChannel(Channel:  Longint);   stdcall ; external 'K8055d .dll';
procedure  ClearAllAnalog;   stdcall; extern al 'K8055d.dll ';
procedure  SetAnalogChannel(Channel:   Longint);  std call; external 'K 8055d.dll';
procedure   SetAllAnalog;  stdcall ; external 'K8055d .dll';
procedure  WriteAllDigital(Data:   Longint);stdcall;   externa l 'K8055d.dll' ;
procedure   ClearDigitalChannel(Channel:   Longint);  stdca ll; external 'K80 55d.dll';
procedure   ClearAllDigital;  stdcall; ex ternal 'K8055d. dll';
procedure  SetDigitalChannel(Channel:   Longint);   stdcall; external  'K8055d.dll' ;
procedure   SetAllDigital;  stdca ll; external 'K80 55d.dll';
function  ReadDigitalChannel(Channel:  Longint):   Boolean;  stdcall ; external 'K8055 d.dll';
function   ReadAllDigital:  Longint;  stdcall; ex ternal 'K8055d. dll';
function   ReadCounter(CounterNr:  Longint):  Longint;  stdcal l; external 'K805 5d.dll';
procedure   ResetCounter(CounterNr:  Longint);   stdcall; ext ernal 'K8055d.d ll';
procedure   SetCounterDebounceTime(CounterNr,    DebounceTime:Longint);   stdcal l; external
'K8055d.dll';


procedure   TForm1.FormClose(Sender:  TObject;   var  Action:  TCloseAction);
begin
   CloseDevice;
end;
procedure  TForm1.Button1Click(Sender:   TObject);
var   h,CardAddr:longint;
begin
   CardAddr:= 3-(integer(SK5.Checked)   +  integer(SK6.Checked)  *   2);
   h:=  OpenDevice(CardAddr);
  case  h of
     0..3:   label12.caption:='Card '+  inttostr(h)+'  connected';

{----------------------------C++--------------------------------------------------------}






In diesem Anwendungsbeispiel werden die Arbeitsweisen und die Funktionen der K8055.DLL erklärt.
Auch werden die 2 wichtigsten DLL -Signale: OpenDevice and CloseDevice verdeutlicht.

Code:

//Listing K8055D.h
#ifdef __cplusplus
extern "C" {
#endif
#define   FUNCTION  __decl spec(dllim port)
FUNCTION long  __stdcall  OpenDevice(l ong  CardAddress);
FUNCTION __ stdcall   CloseDevice();
FUNCTION  long __ stdcall   ReadAnalogChannel(lon g  Channel);
FUNCTION  __stdcall   ReadAllAnalog(long  *Data1,  lo ng  *Data2);
FUNCTION __stdca ll   OutputAnalogChannel(long  Channel,  long  Data);
FUNCTION __stdc all  OutputAllAnalog(lo ng Data1,  long  Data2);
FUNCTION __stdca ll   ClearAnalogChannel(long  Channel);
FUNCTION __std call  ClearAllAnalog();
FUNCTION __ stdcall   SetAnalogChannel(long  Channel);
FUNCTION __s tdcall   SetAllAnalog();
FUNCTION  __stdcall   WriteAllDigital(long  Data);
FUNCTION __stdc all   ClearDigitalChannel(long  Channel);
FUNCTION __st dcall   ClearAllDigital();
FUNCTI ON __stdc all   SetDigitalChannel(long  Channel);
FUNCTION __s tdcall   SetAllDigital();
FUNCTION  bool __st dcall   ReadDigitalChannel(long  Channel);
FUNCTION l ong __std call  ReadAllDigital();
FUNCTION lo ng __stdc all  ReadCounter(long  CounterNr);
FUNCTION __s tdcall   ResetCounter(long  CounterNr);
FUNCTION __st dcall   SetCounterDebounceTime(long  CounterNr,  lo ng  DebounceTime);
#ifdef  __cplusplus
}
# endif
//Listing   Unit1.cpp
//------- ------------- ------------ ------------ ------------ ------------ -------
#include  <vcl.h>
#pragma   hdrstop
#include "Unit1. h"
#include "K8055D. h"
//-------- ------------ ------------ ------------- ------------ ------------ ------
#pragma   package(smart_init)
#pragma   resource  "*.dfm"
TForm1   *Form1;
//------- ------------- ------------ ------------ ------------ ------------- ------
__fastcall  TForm1::TForm1(TComponent*   Owner)
         : TForm(Owner)
{
}
/ /----------- ------------ ------------ ------------ ------------- ------------ ---
void __ fastcall   TForm1::Connect1Click(TObject  *Sender)
{
  int  CardAddr = 3  - (int (CheckBox1->Checked)  +   in t(CheckBox2->Checked)   *  2);
  int  h  = OpenDevice(CardAddr);
  switch (h) {
     case  0 :
     case   1 :
    case  2 :
    case  3 :
       Label1->Caption  = "Card "  + IntToStr(h)  + "  connected";
       break;
     case   -1 :



Label1->Caption =  "Card "  + IntToStr(CardAddr)  +  " not  found";
  }
}
//----- ------------ ------------ ------------- ------------ ------------ ---------
void __fastc all  TForm1::FormClose(TObject  *Sender,   TCloseAction  &Action)
{
   CloseDevice;
}
//---- ------------ ------------ ------------ ------------- ------------ ----------

Wie du siehst musst du nur im Beispiel C++ Programm nachsehen was die dll kann.
dannach im implementationsteil von delphi als external deklarieren.
nachsehen wie das Teil angesprochn wird und in delphi einfügen
(cardadress...)
Danach einfach die entsprechende Funktion oder Procedure mit ihren Parametern aufrufen

Fertig - wenn du noch porbleme hast einfach per mail rühren.
Bei mir hats am Anfang auch nicht geklappt.
Wenn mans mal raushat gehts dann dafür bei all diesen Systemen.
Bei mir mitlerweile bei drei einwandfrei.

[edit=Sharky]Delphi- und C-Tags gesetzt. Mfg, Sharky[/edit]

[HorstBS]

Hi! Danke fuer den Code... ich sitz mitlerweile schon seit mehr als einer Woche an dem Problem und hab immernoch keine Loesung.

Allerdings bin ich mittlerweile schon soweit das ich ohne die dll eine Verbindung habe:

const device='\\.\USB#Vid_0403&Pid_f068#EL2WP4T4#{a5dcbf10-6530-11d2-901f-04fb951ed}' Habe den genauen Namen von dem Wandler in der Registry nachgelesen und es scheint auch so zu funktionieren.

Delphi-Quellcode:

var DeviceHandle :THandle;
begin

  DeviceHandle := CreateFile(device, Generic_write, File_share_write, nil, open_existing, 0, 0);

  //Überprüft ob Verbindung steht
  if DeviceHandle = INVALID_HANDLE_VALUE then
  begin form1.Label1.Caption:='Verbindung klappt nicht'; end  else
  begin form1.Label1.Caption:='Verbindung klappt';       end; 


  CloseHandle (DeviceHandle);
end;

Jetzt habe ich ein Problem mit der Kommunitkation. Laut anleitung muss ich ein Hex-Code schicken der ungefaehr so aufgebaut ist:

02 //Rahmen Begin
35 //Port 5 wird angesprochen
03 //Rahmen Ende

habe es wie folgt versucht:

Delphi-Quellcode:

var command, inDummy, count:longword;
    USBWRITE:Boolean;
    DeviceHandle :THandle;
begin

  command:=$2+$35+$3;
  inDummy:=0;

  DeviceHandle := CreateFile(device, Generic_write, File_share_write, nil, open_existing, 0, 0);

  USBWRITE := DeviceIoControl(DeviceHandle, $04,
                              @command, sizeof(command),
                              @inDummy, sizeof(inDummy),
                              count, NIL);

  if usbwrite then begin Form1.Label2.Caption:='geht'; end else
                   begin Form1.Label2.Caption:='geht nicht'; end;  //Das bekomme ich in dem Fall als Antwort.

  CloseHandle (DeviceHandle);
end;

und gelesen wird so:

Delphi-Quellcode:

var command, count:longword;
    inBytes:DWord;
    USBREAD:Boolean;
    DeviceHandle :THandle;
begin

  command:=$2+$35+$3;

  DeviceHandle := CreateFile(device, Generic_write, File_share_write, nil, open_existing, 0, 0);

  USBREAD := DeviceIoControl(DeviceHandle, $04,
                             @command, sizeof(command),
                             @inBytes, sizeof(inBytes),
                             count, NIL);

  if usbread then begin Form1.Label3.Caption:='geht'; end else
                  begin Form1.Label3.Caption:='geht nicht'; end;  //Das bekomme ich in dem Fall als Antwort.

  CloseHandle (DeviceHandle);
end;

Also aus dem was ich bisher nachgelesen hab muesste das so klappen..
Eine Antwort hab ich laut Anleitung auch zu erwarten.. also woran kann das liegen? Sende ich vielleicht was falsches oder sende ich ueberhaupt?

[ste_ett]

Eventuell ist gemeint, dass du das entsprechende ASCII-Zeichen zu dem Hex-Code schickst.

[RavenIV]

du solltest zur Kommunikation mit dem Gerät die beiliegende DLL verwenden.

bei dem C/C++ -Beispiel ist sicher eine .h-Datei dabei, in der die Funktionen der DLL beschrieben sind. Diese .h-Datei musst Du in eine .pas-Datei "übersetzen".
Anschliessend kannst du diese Datei in Dein Projekt einbinden und die Funktionen der DLL benutzen.

Vermutlich musst Du das Gerät öffnen, was senden, was empfangen, Gerät schliessen.
Sollte alles (und evtl noch mehr) in der DLL und .h-Datei vorhanden sein.

bei Fragen kannst Du mir gerne eine PN oder email schicken...

[Robert Marquardt]

Zitat von HorstBS:

const device='\\.\USB#Vid_0403&Pid_f068#EL2WP4T4#{a5dcbf10-6530-11d2-901f-04fb951ed}' Habe den genauen Namen von dem Wandler in der Registry nachgelesen und es scheint auch so zu funktionieren.

Das muss nicht immer funktionieren. Probier mal '\\.\EL2WP4T4'. Es ist wahrscheinlich das der Treiber diesen symbolischen Namen anbietet.
Warum verwendest du nicht die DLL?

[Robert Marquardt]

Zitat von HorstBS:

Jetzt habe ich ein Problem mit der Kommunitkation. Laut anleitung muss ich ein Hex-Code schicken der ungefaehr so aufgebaut ist:

02 //Rahmen Begin
35 //Port 5 wird angesprochen
03 //Rahmen Ende

Na das sagt doch klar das man 3 Bytes schreiben soll.

Delphi-Quellcode:

var
  count: longword;
  command, inDummy: array [0..2] of Char;
  USBWRITE:Boolean;
  DeviceHandle :THandle;
begin
  commmand[0] := #$02;
  commmand[1] := #$35;
  commmand[2] := #$03;
  inDummy[0] := #0;
  inDummy[1] := #0;
  inDummy[2] := #0;

  DeviceHandle := CreateFile(device, Generic_write, File_share_write, nil, open_existing, 0, 0);

  USBWRITE := DeviceIoControl(DeviceHandle, $04,
                              @command[0], sizeof(command),
                              @inDummy[0], sizeof(inDummy),
                              count, NIL);

  if usbwrite then begin Form1.Label2.Caption:='geht'; end else
                   begin Form1.Label2.Caption:='geht nicht'; end;  //Das bekomme ich in dem Fall als Antwort.

  CloseHandle (DeviceHandle);
end;

[HorstBS]

Nene hab grad nochmal alles durchprobiert..das scheint so wirklich nicht zu funktionieren..schade.

Also es hilft ja alles nichts.. muss wohl doch versuchen die dll zu verwenden auch wenn ich davon keine Ahnung hab. Ich werds mal so versuchen wie in daisychain's Beispiel beschrieben..

MfG HorstBS

[HorstBS]

So also im Prinzip muesste ich jetzt folgende Funktionen nach Delphi konvertieren:

Code:

FTD2XX_API
FT_STATUS WINAPI FT_Open(int deviceNumber, FT_HANDLE *pHandle);

FTD2XX_API
FT_STATUS WINAPI FT_OpenEx(PVOID pArg1,DWORD Flags, FT_HANDLE *pHandle);

FTD2XX_API
FT_STATUS WINAPI FT_Close(FT_HANDLE ftHandle );

FTD2XX_API
FT_STATUS WINAPI FT_Read(FT_HANDLE ftHandle, LPVOID lpBuffer, DWORD nBufferSize,LPDWORD lpBytesReturned);

FTD2XX_API
FT_STATUS WINAPI FT_Write(FT_HANDLE ftHandle, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesWritten);

schoen und gut und wie mach ich das nun?^^

Hier ist nochmal das beiliegende C++ Programm mit .dll und .h :
http://www.delphipraxis.net/download.php?id=16623

und hier werden die ganzen Funktionen erklaert: http://www.ftdichip.com/Documents/Pr...s/D2XXPG31.pdf