USB Port abfragen mit Delphi?

[HorstBS]

Hallo,
bei dem Versuch Sensorwerte am PC auszuwerten bin ich auf folgendes Problem gestoßen:
Ich moechte ein Delphi Programm schreiben das den USB Port abfragt und mir somit die Messergebnisse liefert. Ist das ueberhaupt moeglich? Ich suche jetzt schon seit Tagen im Internet (auch auf dieser Seite) nach einer moeglichen Loesung aber habe bisher noch keine befriedigende Antwort gefunden. Gibt es nicht einfach irgendeinen simplen Delphi-Code? Fuer Hilfe waere ich sehr dankbar.

MfG HorstBS

[jfheins]

an sich nicht, denn für anwendungen sind nur die geräte sichtbar, nicht der usb-port an sich.

siehe auch: http://www.delphipraxis.net/internal...ct.php?t=72212 insb. Beitrag #5 ;)


es ei denn, der sensor ist ein gerät. dann müsstest du in der anleitung oder beim hersteller erfahren, wie es seine daten abliefert ...

[HorstBS]

Hm der Link bringt mich nicht wirklich weiter den hab ich vorher auch schon gelesen^^

Ich hab aber auch vergessen zu sagen, dass ich noch einen AD-Wandler zwischen dem Sensor und der USB-Schnittstelle hab. Der wandelt die analogen Daten vom Sensor in digitale um und hat halt nen USB Stecker. Bei dem Teil war auch nen Programm dabei, welches die Werte abliest und ausgibt, allerding kann ich damit nicht viel anfangen weil ich ja selbst ein Programm schreiben will um die Ergebnisse auszuwerten.

MfG HorstBS

[Daniel Schuhmann]

Es würde noch helfen, wenn Du sagen könntest, wie "dieses Teil" genau heißt. Gewöhnlich legen Hersteller bei solchen Meßsystemen ein SDK mit bei (meist in Form einer DLL-Datei), über die man auf das Gerät zugreifen kann.

[Robert Marquardt]

Ich rieche einen beratungsresistenten Juengling :->
Ob ich ihn wohl zu einem Imbiss verhackstuecke?

Nee, er soll selber draufkommen das sein Beitrag deutlich suboptimal in Informationsgehalt und Form ist.

[HorstBS]

Also nochmal mein Problem:
Ich habe einen Distanz-Sensor, der die Entfernung zu einem beliebigen Objekt bestimmen soll. Dieser Sensor fuehrt zu einem AD Wandler (USB-AD-Wandler UAD 8). Dieser wandelt die analogen Werte des Sensors in digitale um. Der AD-Wandler ist am USB Port angeschloßen und sendet nun die Werte an den PC.
Ich versuche nun ein Delphi Programm zu schreiben, welches auf den Port zugreift (oder was auch immer) um die Messergebnisse anzuzeigen.
Ich habe jetzt schon mehrere Programme gesehen aber keins scheint zu funktionieren. Deshalb meine Frage: Wie realisiere ich dieses Problem mit Delphi?
Da muss es doch einen Befehl oder so geben?

MfG HorstBS

[DerDan]

Nus sach schon, wie heist denn dein AD Wandler, hat der auch einen Namen.

So wie du das Bisher beschreibst ist ein wenig dünn!


mfg

DerDan

[Robert Marquardt]

Zitat:

Zitat von HorstBS

Dieser Sensor fuehrt zu einem AD Wandler (USB-AD-Wandler UAD 8). Dieser wandelt die analogen Werte des Sensors in digitale um. Der AD-Wandler ist am USB Port angeschloßen und sendet nun die Werte an den PC.

Diese Beschreibung ist einfach Unsinn. Am USB haengen USB-Geraete. Man kann also nur mit Geraeten reden und nicht mit "dem USB Port".
Der UAD 8 ist also ein USB-Geraet. Ein USB-Geraet ist immer aus einer USB-Klasse. Je nach Klasse wird das Geraet ueber unterschiedliche APIs angesprochen.
Ein USB Stick ist z. B. aus der Mass Storage Klase und wird nur ueber das normale File API angesprochen.
Das Geraet kann auch in die "Custom"-Klasse fallen. Das bedeutet das der Hersteller einen Treiber mitliefern muss. Ueblicherweise gibt es dann auch noch eine DLL oder ein OCX zum Zugriff ueber den Treiber. Das ist die Schnittstelle die man dann unter Delphi ansprechen kann.

[Daniel Schuhmann]

Wenn ich das nicht ganz falsch verstanden habe, handelt es sich um dieses Gerät (Bausatz, PDF-Anleitung). Das Gerät verwendet einen RS232-USB-Wandler zur Kommunikation, es stellt also auf dem System einen virtuellen COM-Port zur Verfügung. Somit wird für den Zugriff eine Serial-Port-Komponente benötigt, die Befehle zum Abfragen sowie die Einstellung der seriellen Schnittstelle finden sich in der schon genannten Anleitung.

[HorstBS]

Also danke erstmal fuer die Antwort, die hat mich ein klein bisschen weitergebracht.
Also der AD Wandler funktioniert so, dass ich ihm Befehle zusende und er mir die gewuenschten Ergebnisse zurueck sendet. Bei dem Ding war auch ein C++ Programm Beispiel dabei, welches diesen "Verbindungsaufbau" und die Kommunikation zwischen PC und Wandler regelt.
(Auch eine .dll Datei ist dabei). Und eben das will ich mit Delphi realisieren.
In wie weit ich dabei auf die .dll Datei zugreifen muss, weiß ich nicht, zumal ich die ja ueberhaupt nicht lesen kann. Es geht also um die Kommunikation zwischen PC (Delphi Programm) und AD-Wandler.
Das Ding heißt wirklich nur "USB-AD-Wandler UAD 8" mehr Informationen hab ich leider nicht dazu auch nicht zu welcher USB-Klasse es gehoert. Allerdings waren auch Treiber dabei die ich bereits installiert habe.
MfG HorstBS

[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]

:roll:
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:

Delphi-Quellcode:

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? :gruebel:

[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:

Zitat von HorstBS

Delphi-Quellcode:

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:

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

[Basilikum]

Code:

typedef PVOID   FT_HANDLE;
typedef ULONG   FT_STATUS;

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);

Delphi-Quellcode:

Const
  FTD2xxLib = 'FTD2XX.DLL';

Type
  FT_HANDLE = PPointer;
  PFT_HANDLE = ^FT_HANDLE;
  FT_STATUS = DWORD;

Function FT_Open(deviceNumber : Integer;pHandle : PFT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_OpenEx(pArg1 : Pointer;Flags : DWORD;pHandle : PFT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Close(ftHandle : FT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Read(ftHandle : FT_HANDLE;lpBuffer : Pointer;nBufferSize : DWORD;lpBytesReturned : PDWORD) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Write(ftHandle : FT_HANDLE;lpBuffer : Pointer;nBufferSize : DWORD;lpBytesWritten : PDWORD) : FT_STATUS; StdCall; External FTD2xxLib;

[Robert Marquardt]

Nicht schlecht, aber noch nicht so schoen wie es sein koennte.

Delphi-Quellcode:

Const
  FTD2xxLib = 'FTD2XX.DLL';

Type
  FT_HANDLE = Pointer;
  FT_STATUS = DWORD;

Function FT_Open(deviceNumber : Integer; var Handle : FT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_OpenEx(pArg1 : Pointer; Flags : DWORD; var Handle : FT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Close(ftHandle : FT_HANDLE) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Read(ftHandle : FT_HANDLE; lpBuffer : Pointer; nBufferSize : DWORD; var BytesReturned : DWORD) : FT_STATUS; StdCall; External FTD2xxLib;

Function FT_Write(ftHandle : FT_HANDLE; lpBuffer : Pointer; nBufferSize : DWORD; var BytesWritten : DWORD) : FT_STATUS; StdCall; External FTD2xxLib;

Ob man bei FT_Read einen ungetypten "var Buffer" und bei FT_Write entsprechend "const Buffer" nimmt ist Geschmackssache.
Ich wuerde es vorziehen, da es dann mit ReadFile bzw WriteFile korrespondiert.

[HorstBS]

Super dankeschoen! Damit kann ich doch schon wieder was anfangen.. nur was trag ich fuer
"ftHandle : FT_HANDLE" ein..also als Parameter?
Krieg da immer nen Fehler :\

[DerDan]

Ich denk mal du musst mit FT_Open das Handle holen und in allen Funktionen verwenden


könntest natürlich auch ein Objekt als hülle drumrum basteln


mfg


DerDan

[daisychain]

:?
Also probier mal das:

Neue Anwendung einen Button und ein Label.
Doppelklicken auf den Button.
Zwischen Prozedure und begin einfügen:
var
FT_Handle : THandle;
cardadress : longint;
s1 : string;

zwischen begin und end:

cardadress := 0;
Ft_Open(cardadress,Ft_handle);
s1 := FT_Handle;
label1.caption := s1;
FT_Close(FT_Handle);

zwischen implementation und procedure:
funktion FT_Open(cardadress: longint; FT_Handle : THandle):Ft_Handle; stdcall; external 'FTD2XX.dll';
procedure FT_Close(FT_Handle:THandle); stdcall ; external 'FTD2XX.dll';

Wie schon gesagt bin ich ein Anfänger kenne mich mit Handel nicht so gut aus.

[Robert Marquardt]

Na das ist keine gute Idee den Handle anzeigen zu wollen.
Ein Handle taugt nur zu einer Sache und das ist man reicht ihn herum.

[v2afrank]

Schau die doch alternativ mal die D2XXUnit unter http://www.ftdichip.com/Projects/Cod...les/Delphi.htm . Ich denke die hilft Dir auch weiter

[daisychain]

Hallo Robert,

hier ging es mir nicht darum das Handle anzuzeigen,
sondern die Funktion zu testen.

Wenn das Gerät keine Fehlermeldung bringt,
dann können auch alle anderen Befehle der DLL
integriert und genutzt werden.