SoundLevel in PB

[kaitec]

Hallo, ich möchte über die RS232 Schnittelle eine Lichtorgel steuern... aber wie bekomme ich den Level des Ausgangssignanls? Also den ausgangs Pegel der Soundkarte?

Wäre für Hilfe sehr dankbar...

[Andre]

Hast Du schonmal die MVCOM UserLib (gibts auf www.PureArea.net) angeschaut?

Diese sollte zum Auslesen + ggf. Steuersignale senden gut geeignet sein.

[kaitec]

Mit dem Steuersignal für die RS232 hab ich keine Problem... dafür hab ich schon ein laufenen Code! Ich brauch nur irgendwas (es geht auch Include ASM) um den Ausgangs Pegel irgendwie zu messen!


MfG

[Falko]

Ich finde, dieses ist in der Hardwareecke besser aufgehoben und habe
es dort hin verschoben.

Schon mal was mit der Port.DLL von B.Kainka probiert?
Die soll auch Soundbefehle für Soundkarten unterstützen. Leider habe
ich dies noch nicht getestet. Wichtig, für XP gibt es eine neuere PORT.DLL
mit der Versionsnummer 1.0.0.3 .

Gruß, Falko

[kaitec]

wo ist den die Port.dll die du meinst???

[Falko]

http://www.b-kainka.de/download.htm

Direktlink für XP: http://www.b-kainka.de/port.zip

Ich hoffe die hilft dir weiter. Bei mir funktioniert schon das
Gruß Falko

[kaitec]

also... ich kann mit der DLL nix anfagen, weil ich nicht weis wie die funzt...

könntest du mir da bisschen helfen?

[Falko]

Hier habe ich mit TS-Soft tool eine PBI erstellt, mit der man die Funktionen der Port.DLL nutzen kann.

Wie ich zu Anfang gesagt hatte. Mit dem Soundfunktionen habe ich noch
gemacht. Wohl aber mit dem Microsekundendelay, welches hervorragend funktioniert

diese Datei bitte z.B. als Sound.pbi benennen die dann am Anfang includiert werden muss. Danach einfach die Befehle ausprobieren. Ich kanns mal probieren, aber es geht nicht gleich sofort.

Code: Alles auswählen

; Source generiert durch DLL2PBLib
; Copyright 2005 by Thomas Schulz (TS-Soft)


; Globale Variablen deklaration
Global RS_CLOSECOM.l
Global RS_CTS.l
Global RS_DCD.l
Global RS_DELAY.l
Global RS_DELAYUS.l
Global RS_DSR.l
Global RS_DTR.l
Global RS_INPORT.l
Global RS_JOYBUTTON.l
Global RS_JOYR.l
Global RS_JOYSTICK.l
Global RS_JOYU.l
Global RS_JOYV.l
Global RS_JOYX.l
Global RS_JOYY.l
Global RS_JOYZ.l
Global RS_OPENCOM.l
Global RS_OUTPORT.l
Global RS_READBYTE.l
Global RS_REALTIME.l
Global RS_RI.l
Global RS_RTS.l
Global RS_SENDBYTE.l
Global RS_SOUNDBUSY.l
Global RS_SOUNDCAPIN.l
Global RS_SOUNDCAPOUT.l
Global RS_SOUNDGETBYTES.l
Global RS_SOUNDGETRATE.l
Global RS_SOUNDIN.l
Global RS_SOUNDIS.l
Global RS_SOUNDOUT.l
Global RS_SOUNDSETBYTES.l
Global RS_SOUNDSETRATE.l
Global RS_SSOUNDIN.l
Global RS_SSOUNDOUT.l
Global RS_TIMEINIT.l
Global RS_TIMEINITUS.l
Global RS_TIMEOUT.l
Global RS_TIMEREAD.l
Global RS_TIMEREADUS.l
Global RS_TXD.l

; Init-Funktion
ProcedureDLL PORTDLL_Init()
  Shared DLL.l
  DLL = LoadLibrary_("PORT.DLL")
  If DLL
    RS_CLOSECOM = GetProcAddress_(DLL, "CLOSECOM")
    RS_CTS = GetProcAddress_(DLL, "CTS")
    RS_DCD = GetProcAddress_(DLL, "DCD")
    RS_DELAY = GetProcAddress_(DLL, "DELAY")
    RS_DELAYUS = GetProcAddress_(DLL, "DELAYUS")
    RS_DSR = GetProcAddress_(DLL, "DSR")
    RS_DTR = GetProcAddress_(DLL, "DTR")
    RS_INPORT = GetProcAddress_(DLL, "INPORT")
    RS_JOYBUTTON = GetProcAddress_(DLL, "JOYBUTTON")
    RS_JOYR = GetProcAddress_(DLL, "JOYR")
    RS_JOYSTICK = GetProcAddress_(DLL, "JOYSTICK")
    RS_JOYU = GetProcAddress_(DLL, "JOYU")
    RS_JOYV = GetProcAddress_(DLL, "JOYV")
    RS_JOYX = GetProcAddress_(DLL, "JOYX")
    RS_JOYY = GetProcAddress_(DLL, "JOYY")
    RS_JOYZ = GetProcAddress_(DLL, "JOYZ")
    RS_OPENCOM = GetProcAddress_(DLL, "OPENCOM")
    RS_OUTPORT = GetProcAddress_(DLL, "OUTPORT")
    RS_READBYTE = GetProcAddress_(DLL, "READBYTE")
    RS_REALTIME = GetProcAddress_(DLL, "REALTIME")
    RS_RI = GetProcAddress_(DLL, "RI")
    RS_RTS = GetProcAddress_(DLL, "RTS")
    RS_SENDBYTE = GetProcAddress_(DLL, "SENDBYTE")
    RS_SOUNDBUSY = GetProcAddress_(DLL, "SOUNDBUSY")
    RS_SOUNDCAPIN = GetProcAddress_(DLL, "SOUNDCAPIN")
    RS_SOUNDCAPOUT = GetProcAddress_(DLL, "SOUNDCAPOUT")
    RS_SOUNDGETBYTES = GetProcAddress_(DLL, "SOUNDGETBYTES")
    RS_SOUNDGETRATE = GetProcAddress_(DLL, "SOUNDGETRATE")
    RS_SOUNDIN = GetProcAddress_(DLL, "SOUNDIN")
    RS_SOUNDIS = GetProcAddress_(DLL, "SOUNDIS")
    RS_SOUNDOUT = GetProcAddress_(DLL, "SOUNDOUT")
    RS_SOUNDSETBYTES = GetProcAddress_(DLL, "SOUNDSETBYTES")
    RS_SOUNDSETRATE = GetProcAddress_(DLL, "SOUNDSETRATE")
    RS_SSOUNDIN = GetProcAddress_(DLL, "SSOUNDIN")
    RS_SSOUNDOUT = GetProcAddress_(DLL, "SSOUNDOUT")
    RS_TIMEINIT = GetProcAddress_(DLL, "TIMEINIT")
    RS_TIMEINITUS = GetProcAddress_(DLL, "TIMEINITUS")
    RS_TIMEOUT = GetProcAddress_(DLL, "TIMEOUT")
    RS_TIMEREAD = GetProcAddress_(DLL, "TIMEREAD")
    RS_TIMEREADUS = GetProcAddress_(DLL, "TIMEREADUS")
    RS_TXD = GetProcAddress_(DLL, "TXD")
  EndIf
EndProcedure
; End-Funktion
ProcedureDLL PORTDLL_End()
  Shared DLL.l
  FreeLibrary_(DLL)
EndProcedure
; Allgemeine Funktionen
ProcedureDLL.l RS_CLOSECOM()
  ProcedureReturn CallFunctionFast(RS_CLOSECOM)
EndProcedure

ProcedureDLL.l RS_CTS()
  ProcedureReturn CallFunctionFast(RS_CTS)
EndProcedure

ProcedureDLL.l RS_DCD()
  ProcedureReturn CallFunctionFast(RS_DCD)
EndProcedure

ProcedureDLL.l RS_DELAY(a.l)
  ProcedureReturn CallFunctionFast(RS_DELAY,a)
EndProcedure

ProcedureDLL.l RS_DELAYUS(a.l)
  ProcedureReturn CallFunctionFast(RS_DELAYUS,a)
EndProcedure

ProcedureDLL.l RS_DSR()
  ProcedureReturn CallFunctionFast(RS_DSR)
EndProcedure

ProcedureDLL.l RS_DTR(a.l)
  ProcedureReturn CallFunctionFast(RS_DTR,a)
EndProcedure

ProcedureDLL.l RS_INPORT(a.l)
  ProcedureReturn CallFunctionFast(RS_INPORT,a)
EndProcedure

ProcedureDLL.l RS_JOYBUTTON()
  ProcedureReturn CallFunctionFast(RS_JOYBUTTON)
EndProcedure

ProcedureDLL.l RS_JOYR()
  ProcedureReturn CallFunctionFast(RS_JOYR)
EndProcedure

ProcedureDLL.l RS_JOYSTICK(a.l,b.l,c.l,d.l,e.l,f.l,g.l)
  ProcedureReturn CallFunctionFast(RS_JOYSTICK,a,b,c,d,e,f,g)
EndProcedure

ProcedureDLL.l RS_JOYU()
  ProcedureReturn CallFunctionFast(RS_JOYU)
EndProcedure

ProcedureDLL.l RS_JOYV()
  ProcedureReturn CallFunctionFast(RS_JOYV)
EndProcedure

ProcedureDLL.l RS_JOYX()
  ProcedureReturn CallFunctionFast(RS_JOYX)
EndProcedure

ProcedureDLL.l RS_JOYY()
  ProcedureReturn CallFunctionFast(RS_JOYY)
EndProcedure

ProcedureDLL.l RS_JOYZ()
  ProcedureReturn CallFunctionFast(RS_JOYZ)
EndProcedure

ProcedureDLL.l RS_OPENCOM()
  ProcedureReturn CallFunctionFast(RS_OPENCOM)
EndProcedure

ProcedureDLL.l RS_OUTPORT(a.l,b.l)
  ProcedureReturn CallFunctionFast(RS_OUTPORT,a,b)
EndProcedure

ProcedureDLL.l RS_READBYTE()
  ProcedureReturn CallFunctionFast(RS_READBYTE)
EndProcedure

ProcedureDLL.l RS_REALTIME(a.l)
  ProcedureReturn CallFunctionFast(RS_REALTIME,a)
EndProcedure

ProcedureDLL.l RS_RI()
  ProcedureReturn CallFunctionFast(RS_RI)
EndProcedure

ProcedureDLL.l RS_RTS(a.l)
  ProcedureReturn CallFunctionFast(RS_RTS,a)
EndProcedure

ProcedureDLL.l RS_SENDBYTE(a.l)
  ProcedureReturn CallFunctionFast(RS_SENDBYTE,a)
EndProcedure

ProcedureDLL.l RS_SOUNDBUSY()
  ProcedureReturn CallFunctionFast(RS_SOUNDBUSY)
EndProcedure

ProcedureDLL.l RS_SOUNDCAPIN()
  ProcedureReturn CallFunctionFast(RS_SOUNDCAPIN)
EndProcedure

ProcedureDLL.l RS_SOUNDCAPOUT()
  ProcedureReturn CallFunctionFast(RS_SOUNDCAPOUT)
EndProcedure

ProcedureDLL.l RS_SOUNDGETBYTES()
  ProcedureReturn CallFunctionFast(RS_SOUNDGETBYTES)
EndProcedure

ProcedureDLL.l RS_SOUNDGETRATE()
  ProcedureReturn CallFunctionFast(RS_SOUNDGETRATE)
EndProcedure

ProcedureDLL.l RS_SOUNDIN(a.l,b.l)
  ProcedureReturn CallFunctionFast(RS_SOUNDIN,a,b)
EndProcedure

ProcedureDLL.l RS_SOUNDIS()
  ProcedureReturn CallFunctionFast(RS_SOUNDIS)
EndProcedure

ProcedureDLL.l RS_SOUNDOUT(a.l,b.l)
  ProcedureReturn CallFunctionFast(RS_SOUNDOUT,a,b)
EndProcedure

ProcedureDLL.l RS_SOUNDSETBYTES(a.l)
  ProcedureReturn CallFunctionFast(RS_SOUNDSETBYTES,a)
EndProcedure

ProcedureDLL.l RS_SOUNDSETRATE(a.l)
  ProcedureReturn CallFunctionFast(RS_SOUNDSETRATE,a)
EndProcedure

ProcedureDLL.l RS_SSOUNDIN(a.l,b.l)
  ProcedureReturn CallFunctionFast(RS_SSOUNDIN,a,b)
EndProcedure

ProcedureDLL.l RS_SSOUNDOUT(a.l,b.l)
  ProcedureReturn CallFunctionFast(RS_SSOUNDOUT,a,b)
EndProcedure

ProcedureDLL.l RS_TIMEINIT()
  ProcedureReturn CallFunctionFast(RS_TIMEINIT)
EndProcedure

ProcedureDLL.l RS_TIMEINITUS()
  ProcedureReturn CallFunctionFast(RS_TIMEINITUS)
EndProcedure

ProcedureDLL.l RS_TIMEOUT(a.l)
  ProcedureReturn CallFunctionFast(RS_TIMEOUT,a)
EndProcedure

ProcedureDLL.l RS_TIMEREAD()
  ProcedureReturn CallFunctionFast(RS_TIMEREAD)
EndProcedure

ProcedureDLL.l RS_TIMEREADUS()
  ProcedureReturn CallFunctionFast(RS_TIMEREADUS)
EndProcedure

ProcedureDLL.l RS_TXD(a.l)
  ProcedureReturn CallFunctionFast(RS_TXD,a)
EndProcedure

Zur Beschreibung der Port.dll ist die Referenz von B.Kainka hierzu:

########################################################################
## ##
## Referenz zur PORT.DLL ##
## ##
########################################################################

Alle Funktionsnamen müssen in Großbuchstaben angegeben werden (außer bei
Java). Einige Funktionen funktionieren nicht unter Windows NT. Die PORT.DLL
kann sich im SYSTEM-Verzeichnis, im WINDOWS-Verzeichnis oder im
Anwendungsverzeichnis befinden.


Das Laden der PORT.DLL erfolgt unter C/C++ wie folgt:
=====================================================

typedef BYTE (CALLBACK* LPFNDLLFUNC)(WORD);

HINSTANCE hPortDLL;
LPFNDLLFUNC lpfnDllFunc;
char szFuncName[] = "FUNCTIONNAME";
BYTE uReturnValue;
WORD wValue;

hPortDLL = LoadLibrary("port");
lpfnDllFunc = (LPFNDLLFUNC)GetProcAddress(hPortDLL,szFuncName);
uReturnValue = lpfnDllFunc(wValue);

Das Konstrukt "typedef BYTE (CALLBACK* LPFNDLLFUNC)(WORD)" definiert
hierbei einen Funktionspointer für den Aufruf der Funktion in der DLL.
Im Beispiel hat dieser den Rückgabetyp BYTE und erwartet beim Aufruf
einen Parameter vom Typ WORD. Der Name der aus der DLL aufzurufenden
Funktion, wird in der Zeichenkette szFuncName[] abgelegt. Das
eigentlich Laden der DLL in den Adressraum des Programms erfolgt durch
den Aufruf von LoadLibrary(). Der Aufruf von GetProcAddress() besorgt
den zu dem Funktionsnamen zugehörigen Zeiger auf den Einsprungpunkt
der Funktion in der DLL. Die Funktion kann jetzt mit dem zuvor
definierten Funktionspointer gerufen werden. Da das Aufruf-Code-Skelett
für jede zu rufende Funktion immer identisch ist und sich dabei nur
Funktionsname und Funktionspointer-Definition verändern, werden im
Folgenden bei der Deklaration für C/C++ nur noch diese beiden Teile
angegeben.


Das Verwenden der DLL erfolgt unter Java wie folgt:
===================================================

Da Java eigentlich plattformunabhängigen Code erzeugen soll, ist die
Einbindung von DLL's nur unter Wegfall der Portabilität des erzeugten
ByteCode zu realisieren. Dazu verwendet man das von Java mitgelieferte
Java Native Interface (JNI), welches es ermöglicht, "nativen" (Java-
fremden) Code einzubeziehen. Die Deklaration der Funktionen in Java
enthält deshalb das Schlüsselwort "native", welches den Java-Compiler
darüber informiert, daß die eigentliche Implementation der Funktion
in einer anderen Hochsprache erfolgt (in diesem Fall C). Nach der
Deklaration der Funktionen wird dieser Java-Quellcode kompiliert und
es steht eine ".class" Datei zur Verfügung. Aus dieser Datei kann
das von Java mitgelieferte Tool "javah" eine C-konforme Header-Datei
generieren, in der eine Art "Austausch-Datentypen" verwendet werden.
Hat man dann die eigentliche Implementation der Funktionen durchge-
führt, so werden die C-Quellen zu einer weiteren DLL kompiliert.
Diese so entstandene DLL hat den Vorzug, in Java geladen werden zu
können und stellt somit eine Art "Mittler" zwischen Java und den
C-Funktionen dar.

Genau das wird bei der Einbindung der PORT.DLL in Java ausgenutzt.
Es wird eine PortDLLWrapper-Klasse erzeugt, die eine konforme
PortDLLWrapper.dll lädt, welche wiederum die Funktionsaufrufe an die
eigentliche PORT.DLL weitervermittelt. Um also die PORT.DLL-Funktionen
aus Java heraus nutzen zu können, sind die folgenden Dateien notwendig:

1. PortDLLWrapper.class ==> Deklarationen der Funktionsnamen
unter Java
2. PortDLLWrapper.dll ==> Mittler-DLL zwischen Java und
der PORT.DLL
3. PortDLLWrapperException.class ==> Fehlermeldungen aus C für Java

Der Aufruf einer Funktion unter Java erfolgt letztlich durch:

try
{
PortDLLWrapper.<<function_name>>(<<parameter>>);
}
catch (PortDLLWrapperException e)
{
System.err.println("Exception: "+e.getMessage());
}

Insofern nimmt der Aufruf der PORT.DLL-Funktionen unter Java eine
gesonderte Position ein, da der Aufruf nicht direkt erfolgt, sondern
durch die Wrapper-Klasse gekapselt wird. Die Verwendung setzt also
keine erneute Deklaration der Funktionen voraus, sondern lediglich das
Vorhandensein der oben genannten drei Dateien. Zur Erstellung wurde
Java2 SDK 1.2.2 unter Win98 verwendet.


Portbefehle:
============
(nicht unter Windows NT)

INPORT
Lesen eines Ports.
Parameter: Adresse (0..65535)
Rückgabe: Inhalt (Byte) der angegebenen Portadresse

Deklaration in Java:
public static native short inport(int port) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef BYTE (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "INPORT";

Deklaration in Delphi:
Function INPORT(PortAddr: Word):Byte; stdcall; external 'port.dll';

Deklaration in VB und VBA
Declare Function INPORT Lib "Port" (ByVal p%) As Integer


OUTPORT
Ausgabe an einen Port
Parameter: Adresse (0..65535), Daten(0..255)
Rückgabe: keine.

Deklaration in Java:
public static native void outport(int port, short value) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD,BYTE);
char szFuncName[] = "OUTPORT";

Deklaration in Delphi:
Procedure OUTPORT(PortAddr: Word; Data: byte); stdcall; external 'port.dll';

Deklaration in VB und VBA
Declare Function INPORT Lib "Port" (ByVal p%) As Integer


Serielle Schnittstelle:
=======================

OPENCOM
Öffnen der seriellen Schnittstelle
Parameter: Zeichenkette als nullterminierter String
Rückgabe: Bei Fehler 0.

Deklaration in Java:
public static native boolean opencom(String param) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(char*);
char szFuncName[] = "OPENCOM";

Deklaration in Delphi:
Function OPENCOM(S:PCHAR):Integer; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub OPENCOM Lib "Port" (ByVal A$)
Declare Function OPENCOM Lib "Port" (ByVal A$) As Integer

Hinweis: Die Zeichenkette wird direkt Windows übergeben. Unter
Windows 95/98/NT ist folgender Aufruf möglich:
OPENCOM "COM2: baud=19200 data=8 parity=N stop=1"
Unter Windows 95/98 funktioniert auch:
OPENCOM "COM2,19200,N,8,1"


CLOSECOM
Schließen der seriellen Schnittstelle
Parameter: keine
Rückgabe: keine

Deklaration in Java:
public static native boolean closecom() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "CLOSECOM";

Deklaration in Delphi:
Procedure CLOSECOM; stdcall; external 'port.dll';

Deklaration in VB und VBA
Declare Sub CLOSECOM Lib "Port" ()


READBYTE
Lesen eines Bytes von der seriellen Schnittstelle. Diese muß zuvor
geöffnet worden sein.
Parameter: keine
Rückgabe: -1 bei Fehler, sonst das empfangene Byte

Deklaration in Java:
public static native short readbyte() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "READBYTE";

Deklaration in Delphi:
Function READBYTE: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function READBYTE Lib "Port" () As Integer


SENDBYTE
Senden eines Bytes über die serielle Schnittstelle. Diese muß zuvor
geöffnet worden sein.
Parameter: Ein Byte (0..255)
Rückgabe: keine

Deklaration in Java:
public static native void sendbyte(short data) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "SENDBYTE";

Deklaration in Delphi:
Procedure SENDBYTE(Wert: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub SENDBYTE Lib "Port" (ByVal B%)


DSR
Abfragen der seriellen Leitung DSR. Diese muß zuvor geöffnet worden sein.
Parameter: keine
Rückgabe: Zustand der Leitung (1/0)

Deklaration in Java:
public static native boolean DSR() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "DSR";

Deklaration in Delphi:
Function DSR: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function DSR Lib "Port" () As Integer


CTS
Abfragen der seriellen Leitung CTS. Diese muß zuvor geöffnet worden sein.
Parameter: keine
Rückgabe: Zustand der Leitung (1/0)

Deklaration in Java:
public static native boolean CTS() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "CTS";

Deklaration in Delphi:
Function CTS: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function CTS Lib "Port" () As Integer


RI
Abfragen der seriellen Leitung RI. Diese muß zuvor geöffnet worden sein.
Parameter: keine
Rückgabe: Zustand der Leitung (1/0)

Deklaration in Java:
public static native boolean RI() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "RI";

Deklaration in Delphi:
Function RI: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function RI Lib "Port" () As Integer


DCD
Abfragen der seriellen Leitung DCD. Diese muß zuvor geöffnet worden sein.
Parameter: keine
Rückgabe: Zustand der Leitung (1/0)

Deklaration in Java:
public static native boolean DCD() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "DCD";

Deklaration in Delphi:
Function DCD: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function DCD Lib "Port" () As Integer


RTS
Setzen der seriellen Leitung RTS. Diese muß zuvor geöffnet worden sein.
Parameter: Wert(0..1)
Rückgabe: keine

Deklaration in Java:
public static native boolean RTS(boolean mode) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "RTS";

Deklaration in Delphi:
Procedure RTS(Wert: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub RTS Lib "Port" (ByVal Wert%)


TXD
Setzen der seriellen Leitung TxD. Diese muß zuvor geöffnet worden sein.
Parameter: Wert(0..1)
Rückgabe: keine

Deklaration in Java:
public static native boolean TXD(boolean mode) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "TXD";

Deklaration in Delphi:
Procedure TXD(Wert: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub TXD Lib "Port" (ByVal Wert%)


DTR
Setzen der seriellen Leitung DTR. Diese muß zuvor geöffnet worden sein.
Parameter: Wert(0..1)
Rückgabe: keine

Deklaration in Java:
public static native boolean DTR(boolean mode) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "DTR";

Deklaration in Delphi:
Procedure DTR(Wert: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub DTR Lib "Port" (ByVal Wert%)


TIMEOUT
Setzen des Timeouts der seriellen Schnittstelle. Diese muß zuvor
geöffnet worden sein. Trifft während dieser Zeit kein Zeichen
ein, so wird bei READBYTE abgebrochen und -1 zurück geliefert.
Parameter: Zeit in Millisekunden (1..65535)
Rückgabe: vorige Zeit in Millisekunden

Deklaration in Java:
public static native int timeout(int duration) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "TIMEOUT";

Deklaration in Delphi:
Procedure TIMEOUT(Wert: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub TIMEOUT Lib "Port" (ByVal Wert%)


Soundkarte:
===========

SOUNDIS
Stellt fest, ob eine Soundkarte vorhanden ist
Parameter: keine
Rückgabe: 0 oder -1 bzw. True oder False

Deklaration in Java:
public static native boolean soundis() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDIS";

Deklaration in Delphi:
Function SOUNDIS:Boolean; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function SOUNDIS Lib "Port" () As Integer


SOUNDCAPIN
Die Soundkartenaufnahme-Eigenschaften werden in einer MessageBox
ausgegeben.
Parameter: keine
Rückgabe: keine

Deklaration in Java:
public static native void soundcapin() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDCAPIN";

Deklaration in Delphi:
Procedure SOUNDCAPIN; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub SOUNDCAPIN Lib "Port" ()


SOUNDCAPOUT
Die Soundkartenwiedergabe-Eigenschaften werden in einer MessageBox
ausgegeben.
Parameter: keine
Rückgabe: keine

Deklaration in Java:
public static native void soundcapout() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDCAPOUT";

Deklaration in Delphi:
Procedure SOUNDCAPOUT; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub SOUNDCAPOUT Lib "Port" ()


SOUNDIN
Startet eine Soundaufnahme (mono) und legt die Daten in den übergebenen
Pufferspeicher ab.
Parameter: Speicher und Speichergröße (in Bytes)
Rückgabe: keine

Deklaration in Java:
public static native int[] soundin(int length) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(BYTE*,DWORD);
char szFuncName[] = "SOUNDIN";

Deklaration in Delphi:
Procedure SOUNDIN(Puffer: Pchar; Size: DWORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub SOUNDIN Lib "Port" (ByVal A$, ByVal Gr As Long)


SOUNDOUT
Startet eine Soundwiedergabe (mono) der Daten des übergebenen Pufferspeichers.
Parameter: Speicher und Speichergröße (in Bytes)
Rückgabe: keine

Deklaration in Java:
public static native void soundout(int[] buffer) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(BYTE*,DWORD);
char szFuncName[] = "SOUNDOUT";

Deklaration in Delphi:
Procedure SOUNDOUT(Puffer: Pchar; Size: DWORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub SOUNDOUT Lib "Port" (ByVal A$, ByVal Gr As Long)


SOUNDGETRATE
Erfagt die eingestellte Abtastfrequenz.
Parameter: keine
Rückgabe: Abtastfrequenz in Samples/Sekunde, z.B. 11025;

Deklaration in Java:
public static native int soundgetrate() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDGETRATE";

Deklaration in Delphi:
Function SOUNDGETRATE: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function SOUNDGETRATE Lib "Port" () As Integer


SOUNDSETRATE
Stellt eine Abtastfrequenz ein.
Parameter: Abtastfrequenz in Samples/Sekunde
Rückgabe: Vorige Abtastfrequenz in Samples/Sekunde. z.B. 11025;

Deklaration in Java:
public static native int soundsetrate(int rate) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)(DWORD);
char szFuncName[] = "SOUNDSETRATE";

Deklaration in Delphi:
Function SOUNDSETRATE(Rate: DWORD):DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function SOUNDSETRATE Lib "Port" (ByVal Rate As Long) As Long


SOUNGETBYTES
Bytes pro Sample erfragen
Parameter: keine
Rückgabe: 1 oder 2. Ein Byte entspricht 8 Bits/Sample. Zwei Bytes
entsprechen 16 Bit/Sample.

Deklaration in Java:
public static native int soundgetbytes() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef WORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDGETBYTES";

Deklaration in Delphi:
Function SOUNDGETBYTES: WORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function SOUNDGETBYTES Lib "Port" () As Integer


SOUNDSETBYTES
Bytes pro Sample einstellen.
Parameter: 1 oder 2. Ein Byte entspricht 8 Bits/Sample. Zwei Bytes
entsprechen 16 Bit/Sample.
Rückgabe: vorige Bytes pro Sample.

Deklaration in Java:
public static native int soundsetbytes(int bytes) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)(DWORD);
char szFuncName[] = "SOUNDSETBYTES";

Deklaration in Delphi:
Function SOUNDSETBYTES(Bytes: DWORD):DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function SOUNDSETBYTES (ByVal Rate As Long) As Long


SOUNDBUSY
Testen, ob die Soundkarte gerade beschäftigt ist.
Parameter: keine
Rückgabe: Zustand der Soundkarte (1/0)

Deklaration in Java:
public static native boolean soundbusy() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "SOUNDBUSY";


Joystick:
=========

Hinweis: Der Joystick muß ordnungsgemäß als Windows-Spielekontroller
eingestellt und kalibriert sein.


JOYX
X-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyx() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYX";

Deklaration in Delphi:
Function JOYX: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYX Lib "Port" () As Long


JOYY
Y-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyy() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYY";

Deklaration in Delphi:
Function JOYY: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYY Lib "Port" () As Long


JOYZ
Z-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyz() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYZ";

Deklaration in Delphi:
Function JOYZ: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYZ Lib "Port" () As Long


JOYR
R-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyr() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYR";

Deklaration in Delphi:
Function JOYR: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYR Lib "Port" () As Long


JOYU
U-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyu() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYU";

Deklaration in Delphi:
Function JOYU: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYU Lib "Port" () As Long


JOYV
V-Position erfragen.
Parameter: keine
Rückgabe: Position als Zahlenwert.

Deklaration in Java:
public static native int joyv() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYV";

Deklaration in Delphi:
Function JOYV: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYV Lib "Port" () As Long


JOYBUTTON
Tastenabfrage
Parameter: keine
Rückgabe: Taste als Zahlenwert.

Deklaration in Java:
public static native int joybutton() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "JOYBUTTON";

Deklaration in Delphi:
Function JOYBUTTON: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function JOYBUTTON Lib "Port" () As Long


JOYSTICK
Gesamtabfrage in einem Aufruf
Parameter: Sieben Variablen zur Aufnahme der Werte
Rückgabe: keine.

Deklaration in Java:
public static native int[] joystick() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(DWORD*,DWORD*,DWORD*,DWORD*,DWORD*,DWORD*,DWORD*);
char szFuncName[] = "JOYSTICK";

Deklaration in Delphi:
Procedure JOYSTICK(VAR X,Y,Z,R,U,V,B:DWORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub JOYSTICK Lib "Port" (ByVal X As Long, ByVal Y As Long ....)


Zeitroutinen:
=============

DELAY
Verzögerung im Millisekundenbereich.
Parameter: Zeit in Millisekunden
Rückgabe: keine

Deklaration in Java:
public static native void delay(int duration) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "DELAY";

Deklaration in Delphi:
Procedure DELAY(ms: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub DELAY Lib "Port" (ByVal ms%)


TIMEINIT
Setzt den Millisekunden-Zeitzähler auf Null.
Parameter: keine
Rückgabe: keine

Deklaration in Java:
public static native void timeinit() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "TIMEINIT";

Deklaration in Delphi:
Procedure TIMEINIT; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub TIMEINIT Lib "Port" ()


TIMEREAD
Millisekunden-Timer auslesen. Das Ergebnis ist die Anzahl der
vergangenen Millisekunden nach Aufruf von TIMEINIT.
Parameter: keine
Rückgabe: Millisekunden als Zahlenwert

Deklaration in Java:
public static native long timeread() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "TIMEREAD";

Deklaration in Delphi:
Function TIMEREAD: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function TIMEREAD Lib "Port" () As Long


DELAYUS
Verzögerung im Mikrosekundenbereich.
Parameter: Zeit in Mikrosekunden
Rückgabe: keine

Deklaration in Java:
public static native void delayus(long duration) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(DWORD);
char szFuncName[] = "DELAYUS";

Deklaration in Delphi:
Procedure DELAYUS(ms: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub DELAYUS Lib "Port" (ByVal ms%)


TIMEINITUS
Setzt den Mikrosekunden-Zeitzälher auf Null.
Parameter: keine
Rückgabe: keine

Deklaration in Java:
public static native void timeinitus() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "TIMEINITUS";

Deklaration in Delphi:
Procedure TIMEINITUS; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub TIMEINITUS Lib "Port" ()


TIMEREADUS
Mikrosekunden-Timer auslesen. Das Ergebnis ist die Anzahl der
vergangenen Mikrosekunden nach Aufruf von TIMEINITUS.
Parameter: keine
Rückgabe: Mikrosekunden als Zahlenwert

Deklaration in Java:
public static native long timereadus() throws PortDLLWrapperException;

Deklaration in C/C++:
typedef DWORD (CALLBACK* LPFNDLLFUNC)();
char szFuncName[] = "TIMEREADUS";

Deklaration in Delphi:
Function TIMEREADUS: DWORD; stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Function TIMEREADUS Lib "Port" () As Long


REALTIME
Höchste Priorität einstellen. Dieser Aufruf ist bei zeitkritischen
Ausgaben nützlich. Er sollte nur kurz aktiviert werden, da alle
anderen Programme dann langsamer laufen.
Parameter: 0 oder 1
Rückgabe: keine

Deklaration in Java:
public static native void realtime(boolean mode) throws PortDLLWrapperException;

Deklaration in C/C++:
typedef int (CALLBACK* LPFNDLLFUNC)(WORD);
char szFuncName[] = "REALTIME";

Deklaration in Delphi:
Procedure REALTIME(d: WORD); stdcall; external 'port.dll';

Deklaration in VB und VBA:
Declare Sub REALTIME Lib "Port" (ByVal i As Boolean)

Wie gesagt, das mit dem Sound muss ich mir noch genauer anschauen und zum Wochenende probieren.

[Edit] Habe Präfixe RS_ vorangestellt wie von TS-Soft korrekt empfohlen

Thomas, danke für den Hinweis [/Edit]

MfG Falko

[Falko]

Am besten wenn der Wrapper als Library mittels Tailbite erzeugt wird, was
aufgrund noch keiner final von Purebasic 4 möglich ist.
Falls du aber mit PB 3.94 testen willst, habe ich hier schon mal eine Lib
erstellt. Die Funktionsaufrufe siehst du aus der PBI-Datei und die Beschreibung wie das eingegeben werden muss aus der original Referenz
von B.Kainka.

Diese folgende Library genauso wie die MVOM ins UserLibrary-Verzeichnis kopiert und du kannst die Funktionen so komfortabel nutzen wie mit MVCOM.
Der Unterschied ist nur. Die Port.DLL muss entweder im selben Verzeichnis
deines Programms oder aber im Windows-, oder Systemverzeichnis kopiert sein.

http://www.falko-pure.de/Programme/PORT_DLL

[ts-soft]

@Falko
Ich hoffe Du hast in der Lib einen Präfix für die Namen genommen, nicht so
wie oben im Source, ansonsten knallt die Lib irgendwann mit anderen
Sourcen