Einbinden einer DLL

[Delphi-Newbie]

Hallo!

Ich gehe davon aus, dass hier schon einige User bezüglich der Einbindung von DLLs in Delphi gefragt haben, aber ich bin seit über 2 Stunden am Ausprobieren und das Internet am Durchforsten, weshalb ich mich jetzt an euch wende:

Ich bin fast Neuling in Delphi, nutze Delphi 2005 und habe bisher noch nie etwas anderes gemacht, als einfache VCL-Formularanwendungen im Rahmen meines Informatikunterrichts in der Schule zu schreiben.

Allerdings bin ich begeisterter Elektroniker und habe gerade anhand einer Anleitung aus dem Internet mein erstes USB-Gerät gebaut. Der Anleitung lag eine DLL bei, mit dessen Hilfe man die Hardware ansteuern kann. Mit DLLs habe ich bisher nie bewusst gearbeitet, und bin entsprechend hilflos.

Folgende Info-Datei beschreibt, wie man die DLL verwenden soll:

usbdmx.dll - Schnittstelle:


-----------
Funktionen:
-----------

GetAllConnectedInterfaces: TSERIALLIST;
GetAllOpenedInterfaces: TSERIALLIST;
SetInterfaceMode(Serial: TSERIAL; Mode: byte): DWORD;
OpenLink(Serial: TSERIAL; DMXOutArray: PDMXArray; DMXInArray: PDMXArray): DWORD;
CloseLink(Serial: TSERIAL): DWORD;
CloseAllLinks: DWORD;
RegisterInterfaceChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD;
UnregisterInterfaceChangeNotification: DWORD;
RegisterInputChangeNotification(Proc: THOSTINPUTCHANGEPROC): DWORD;
UnregisterInputChangeNotification: DWORD;
GetDeviceVersion(Serial: TSERIAL): DWORD;
SetInterfaceAdvTxConfig(Serial: TSERIAL; Control: Byte; Breaktime: word; Marktime: word; Interbytetime: word; Interframetime: word; Channelcount: word; Startbyte: byte): DWORD; stdcall; // >= v1.1
StoreInterfaceAdvTxConfig(Serial: TSERIAL): DWORD; stdcall; // >= v1.1
RegisterInputChangeBlockNotification(Proc: THOSTINPUTCHANGEPROCBLOCK): DWORD; // >= v1.1
UnregisterInputChangeBlockNotification: DWORD; // >= v1.1


-------------------------------------
Object-Pascal Deklarationsvorschläge:
-------------------------------------

function GetAllConnectedInterfaces: TSERIALLIST; stdcall external 'usbdmx.dll';
function GetAllOpenedInterfaces: TSERIALLIST; stdcall external 'usbdmx.dll';
function SetInterfaceMode(Serial: TSERIAL; Mode: byte): DWORD; stdcall external 'usbdmx.dll';
function OpenLink(Serial: TSERIAL; DMXOutArray: PDMXArray; DMXInArray: PDMXArray): DWORD; stdcall external 'usbdmx.dll';
function CloseLink(Serial: TSERIAL): DWORD; stdcall external 'usbdmx.dll';
function CloseAllLinks: DWORD; stdcall external 'usbdmx.dll';
function RegisterInterfaceChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInterfaceChangeNotification: DWORD; stdcall external 'usbdmx.dll';
function RegisterInputChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInputChangeNotification: DWORD; stdcall external 'usbdmx.dll';
function GetDeviceVersion(Serial: TSERIAL): DWORD; stdcall external 'usbdmx.dll';
function SetInterfaceAdvTxConfig(Serial: TSERIAL; Control: Byte; Breaktime: word; Marktime: word; Interbytetime: word; Interframetime: word; Channelcount: word; Startbyte: byte): DWORD; stdcall; stdcall external 'usbdmx.dll';
function StoreInterfaceAdvTxConfig(Serial: TSERIAL): DWORD; stdcall; stdcall external 'usbdmx.dll';
function RegisterInputChangeBlockNotification(Proc: THOSTINPUTCHANGEPROCBLOCK): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInputChangeBlockNotification: DWORD; stdcall external 'usbdmx.dll';


------
Werte:
------
Mode: 0 - Standby; 1 - DMX In -> DMX Out; 2 - PC Out -> DMX Out; 3 - DMX In + PC Out -> DMX Out; 4 - DMX In -> PC In; 5 - DMX In -> DMX Out & DMX In -> PC In; 6 - PC Out -> DMX Out & DMX In -> PC In; 7 - DMX In + PC Out -> DMX Out & DMX In -> PC In;
Version: 0x0100 = v1.00, 0x0110 = v1.10 usw.
ConfigControl: Bit 0: Enable Interbytedelay, Bit 1: Enable Interframedelay, Default = 0
Breaktime: Zeit des Resetpulses, 5,333us Schrittweite, Default = 17
Marktime: Zeit zwischen Resetpuls und Startbyte, 0.666us Schrittweite, Default = 13
Interbytetime: Zeit zwischen zwei Datenbytes (8N2), 0.666us Schrittweite, Default = 0
Interframetime: Zeit zwischen dem letzten Datenbyte und dem Resetpuls, 21,333us Schrittweite, Default = 0
Channelcount: Default = 512
Startbyte: Default = 0


------------------------------
Object-Pascal Typenvorschläge:
------------------------------

PDMXArray = ^TDMXArray;
TDMXArray = array[0..511] of byte;
TSERIAL = array[0..15] of Char;
TSERIALLIST = array[0..31] of TSERIAL;
THOSTDEVICECHANGEPROC = procedure; stdcall;
THOSTINPUTCHANGEPROC = procedure; stdcall;
THOSTINPUTCHANGEPROCBLOCK = procedure(blocknumber: byte); stdcall; // >= v1.1


------------------------
Hilfsroutinenvorschläge:
------------------------

function SerialToSerialstring(Serial: TSERIAL): string;
var i: byte;
begin
Result := '';
for i := 0 to 15 do Result := Result + Serial[i];
end;

function SerialstringToSerial(Serialstr: string): TSERIAL;
var i: byte;
    len: byte;
begin
len := length(Serialstr);
if len > 16 then len := 16;
for i := 0 to 15 do Result[i] := '0';
for i := 1 to len do Result[i + 15 - len] := Serialstr[i];
end;

Ich hab schon alles Mögliche rumprobiert, konnte aber aufgrund meiner mangelnden Vorkenntnisse eigentlich nur raten.
Daher wäre meine Bitte: Wenn sich irgendjemand die Zeit nehmen würde, mir eine Schritt-für-Schritt-Anleitung zu schicken oder besser noch: ein gezipptes Delphi-Projekt, in dem die in der DLL enthaltenen Befehle schon "integriert" sind, wäre ich sehr dankbar...

Im Anhang sind nochmal die oben bereits eingefügte "Anleitung" und das DLL-File.

Ein riesiges Dankeschön schonmal im Voraus und ich freue mich über jede Hilfe,
mit freundlichen Grüßen

der Delphi-(fast)-Newbie (nutze WinXP SP3)
kampfnudel@quantentunnel.de

 

[Kangaxx]

Hallo,

also, deine Aufgaben wird dir hier keine erledigen, helfen werden wir aber gerne!

Im Endeffekt hast du ja schon alles was du brauchst!! Die in deiner Textdatei angebenen "Object-Pascal Deklarationsvorschläge" sind genau das was du brauchst!!

Einfaches vorgehen:

1. Erstell dir eine neue Klasse (am besten in einer neuen Unit)
2. Kopiere die Funktions-Prototypen (das "function..."-Zeug) in den public-Bereich der neuen Klasse.
3. Kopier die anderen Sachen (Typdefinitonen usw. oberhalb der Klasse in die Unit).
4. Kopier die Hilfsmethode unter die Klasse.
5. Die "Werte" würden sich durchaus als Konstanten eignen. Aber hier kannste schaffen wie du willst..

Damit hast du eine fertige Klasse die deine DLL verwendet.
Damit das klappt muss die DLL im selben Verzeichnis wie die spätere Exe-Datei liegen.

Hoffe das hilft!

Gruß, Kangaxx