Code:
#ifndef PORTDLLCHEADER
#define PORTDLLCHEADER
/*******************************************************************************
** C-Header-Definitionen fuer die DLL "port.dll"
*******************************************************************************/
#include <windows.h>
HINSTANCE hDLL;
//#define THEDLL "RSAPI.DLL"
#define THEDLL "PORT.DLL"
// Messagebox
bool mes (char * string)
{
MessageBox (GetActiveWindow (), string, "DLLTEST", MB_OK | MB_ICONINFORMATION);
return (true);
}
bool loaddll (char * name)
{
char s[256];
hDLL = LoadLibrary (name);
if (hDLL == NULL)
{
wsprintf (s, "%s nicht gefunden.", name);
MessageBox (GetFocus (), s, "ERROR", MB_OK | MB_ICONSTOP);
return (false);
}
return (true);
}
void freedll (void)
{
FreeLibrary (hDLL);
}
// RTS
// Setzen der seriellen Leitung RTS. Diese muss zuvor geoeffnet worden sein.
// Parameter: Wert(0..1)
// Rueckgabe: keine
int rts (WORD i)
{
typedef int (CALLBACK* LP1INT)(WORD);
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"RTS");
return p (i);
}
// TXD
// Setzen der seriellen Leitung TxD. Diese muss zuvor geoeffnet worden sein.
// Parameter: Wert(0..1)
// Rueckgabe: keine
int txd (WORD i)
{
typedef int (CALLBACK* LP1INT)(WORD);
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"TXD");
return p (i);
}
// DTR
// Setzen der seriellen Leitung DTR. Diese muss zuvor geoeffnet worden sein.
// Parameter: Wert(0..1)
// Rueckgabe: keine
int dtr (WORD i)
{
typedef int (CALLBACK* LP1INT)(WORD);
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"DTR");
return p (i);
}
// DSR
// Abfragen der seriellen Leitung DSR. Diese muss zuvor geoeffnet worden sein.
// Parameter: keine
// Rueckgabe: Zustand der Leitung (1/0)
WORD dsr (void)
{
typedef WORD (CALLBACK* LP1INT)();
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"DSR");
return p ();
}
// CTS
// Abfragen der seriellen Leitung CTS. Diese muss zuvor geoeffnet worden sein.
// Parameter: keine
// Rueckgabe: Zustand der Leitung (1/0)
WORD cts (void)
{
typedef WORD (CALLBACK* LP1INT)();
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"CTS");
return p ();
}
// RI
// Abfragen der seriellen Leitung RI. Diese muss zuvor geoeffnet worden sein.
// Parameter: keine
// Rueckgabe: Zustand der Leitung (1/0)
WORD ri (void)
{
typedef WORD (CALLBACK* LP1INT)();
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"RI");
return p ();
}
// DCD
// Abfragen der seriellen Leitung DCD. Diese muss zuvor geoeffnet worden sein.
// Parameter: keine
// Rueckgabe: Zustand der Leitung (1/0)
WORD dcd (void)
{
typedef WORD (CALLBACK* LP1INT)();
LP1INT p;
p = (LP1INT)GetProcAddress (hDLL,"DCD");
return p ();
}
// OPENCOM
// Oeffnen der seriellen Schnittstelle
// Parameter: Zeichenkette als nullterminierter String
// Rueckgabe: Bei Fehler 0.
UINT opencom (char * string)
{
typedef UINT (CALLBACK * LP2INT)(char *);
LP2INT p;
p = (LP2INT)GetProcAddress (hDLL, "OPENCOM");
return p (string);
}
// CLOSECOM
// Schliessen der seriellen Schnittstelle
// Parameter: keine
// Rueckgabe: keine
BOOL closecom (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p;
p = (LP2INT)GetProcAddress (hDLL, "CLOSECOM");
return p ();
}
// READBYTE
// Lesen eines Bytes von der seriellen Schnittstelle. Diese muss zuvor
// geoeffnet worden sein.
// Parameter: keine
// Rueckgabe: -1 bei Fehler, sonst das empfangene Byte
UINT readbyte (void)
{
typedef UINT (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT)GetProcAddress (hDLL, "READBYTE");
return p ();
}
// SENDBYTE
// Senden eines Bytes ueber die serielle Schnittstelle. Diese muss zuvor
// geoeffnet worden sein.
// Parameter: Ein Byte (0..255)
// Rueckgabe: keine
int sendbyte (BYTE value)
//int sendbyte (Word wValue)
{
typedef int (CALLBACK* LP2INT)(BYTE);
//typedef int (CALLBACK* LP2INT)(WORD);
LP2INT p; // Funktionszeiger
p = (LP2INT)GetProcAddress (hDLL, "SENDBYTE");
return p (value);
//return p (wValue);
}
// TIMEOUT
// Setzen des Timeouts der seriellen Schnittstelle. Diese muss zuvor
// geoeffnet worden sein. Trifft waehrend dieser Zeit kein Zeichen
// ein, so wird bei READBYTE abgebrochen und -1 zurueck geliefert.
// Parameter: Zeit in Millisekunden (1..65535)
// Rueckgabe: vorige Zeit in Millisekunden
int timeout (WORD wTime)
{
typedef int (CALLBACK* LP2INT)(WORD);
LP2INT p; // Funktionszeiger
p = (LP2INT)GetProcAddress (hDLL, "TIMEOUT");
return p (wTime);
}
/****************** nur für 16Bit-Systeme ********************/
// INPORT
// Lesen eines Ports.
// Parameter: Adresse (0..65535)
// Rueckgabe: Inhalt (Byte) der angegebenen Portadresse
BYTE inport (WORD wPort)
{
typedef BYTE (CALLBACK* LP2INT)(WORD);
LP2INT p;
p = (LP2INT) GetProcAddress (hDLL, "INPORT");
return p (wPort);
}
/************************************************************/
/****************** nur für 16Bit-Systeme ********************/
// OUTPORT
// Ausgabe an einen Port
// Parameter: Adresse (0..65535), Daten(0..255)
// Rueckgabe: keine.
int outport (WORD wPort, BYTE value)
{
typedef int (CALLBACK* LP2INT)(WORD, BYTE);
LP2INT p;
p = (LP2INT) GetProcAddress (hDLL, "OUTPORT");
return p (wPort, value);
}
/************************************************************/
// SOUNDIS
// Stellt fest, ob eine Soundkarte vorhanden ist
// Parameter: keine
// Rueckgabe: 0 oder -1 bzw. True oder False
int soundis (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p;
p = (LP2INT) GetProcAddress (hDLL, "SOUNDIS");
return p ();
}
// SOUNDCAPIN
// Die Soundkartenaufnahme-Eigenschaften werden in einer MessageBox
// ausgegeben.
// Parameter: keine
// Rueckgabe: keine
int soundcapin (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDCAPIN");
return p ();
}
// SOUNDCAPOUT
// Die Soundkartenwiedergabe-Eigenschaften werden in einer MessageBox
// ausgegeben.
// Parameter: keine
// Rueckgabe: keine
int soundcapout (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDCAPOUT");
return p ();
}
// SOUNDIN
// Startet eine Soundaufnahme (mono) und legt die Daten in den uebergebenen
// Pufferspeicher ab.
// Parameter: Speicher und Speichergroesse (in Bytes)
// Rueckgabe: keine
int soundin (BYTE * pBuffer, DWORD dwLength)
{
typedef int (CALLBACK* LP2INT)(BYTE*,DWORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDIN");
return p (pBuffer, dwLength);
}
// SOUNDOUT
// Startet eine Soundwiedergabe (mono) der Daten des uebergebenen Pufferspeichers.
// Parameter: Speicher und Speichergroesse (in Bytes)
// Rueckgabe: keine
int soundout (BYTE * pBuffer, DWORD dwLength)
{
typedef int (CALLBACK* LP2INT)(BYTE*,DWORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDOUT");
return p (pBuffer, dwLength);
}
// SOUNDGETRATE
// Erfagt die eingestellte Abtastfrequenz.
// Parameter: keine
// Rueckgabe: Abtastfrequenz in Samples/Sekunde, z.B. 11025;
WORD soundgetrate (void)
{
typedef WORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDGETRATE");
return p ();
}
// SOUNDSETRATE
// Stellt eine Abtastfrequenz ein.
// Parameter: Abtastfrequenz in Samples/Sekunde
// Rueckgabe: Vorige Abtastfrequenz in Samples/Sekunde. z.B. 11025;
DWORD soundsetrate (DWORD dwSampleRate)
{
typedef DWORD (CALLBACK* LP2INT)(DWORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDSETRATE");
return p (dwSampleRate);
}
// SOUNGETBYTES
// Bytes pro Sample erfragen
// Parameter: keine
// Rueckgabe: 1 oder 2. Ein Byte entspricht 8 Bits/Sample. Zwei Bytes
// entsprechen 16 Bit/Sample.
WORD soundgetbytes (void)
{
typedef WORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDGETBYTES");
return p ();
}
// SOUNDSETBYTES
// Bytes pro Sample einstellen.
// Parameter: 1 oder 2. Ein Byte entspricht 8 Bits/Sample. Zwei Bytes
// entsprechen 16 Bit/Sample.
// Rueckgabe: vorige Bytes pro Sample.
DWORD soundsetbytes (DWORD dwBitsPerSample)
{
typedef DWORD (CALLBACK* LP2INT)(DWORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDSETBYTES");
return p (dwBitsPerSample);
}
// SOUNDBUSY
// Testen, ob die Soundkarte gerade beschaeftigt ist.
// Parameter: keine
// Rueckgabe: Zustand der Soundkarte (1/0)
DWORD soundbusy (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "SOUNDBUSY");
return p ();
}
// JOYX
// X-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyx (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYX");
return p ();
}
// JOYY
// Y-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyy (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYY");
return p ();
}
// JOYZ
// Z-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyz (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYZ");
return p ();
}
// JOYR
// R-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyr (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYR");
return p ();
}
// JOYU
// U-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyu (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYU");
return p ();
}
// JOYV
// V-Position erfragen.
// Parameter: keine
// Rueckgabe: Position als Zahlenwert.
DWORD joyv (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYV");
return p ();
}
// JOYBUTTON
// Tastenabfrage
// Parameter: keine
// Rueckgabe: Taste als Zahlenwert.
DWORD joybutton (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYBUTTON");
return p ();
}
// JOYSTICK
// Gesamtabfrage in einem Aufruf
// Parameter: Sieben Variablen zur Aufnahme der Werte
// Rueckgabe: keine.
int joystick (DWORD *joyX, DWORD *joyY, DWORD *joyZ, DWORD *joyR, DWORD *joyU, DWORD *joyV, DWORD *joyButton)
{
typedef int (CALLBACK* LP2INT)(DWORD*,DWORD*,DWORD*,DWORD*,DWORD*,DWORD*,DWORD*);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "JOYSTICK");
return p (joyX, joyY, joyZ, joyR, joyU, joyV, joyButton);
}
// DELAY
// Verzoegerung im Millisekundenbereich.
// Parameter: Zeit in Millisekunden
// Rueckgabe: keine
int delay (WORD wTime)
{
typedef int (CALLBACK* LP2INT)(WORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "DELAY");
return p (wTime);
}
// TIMEINIT
// Setzt den Millisekunden-Zeitzaehler auf Null.
// Parameter: keine
// Rueckgabe: keine
int timeinit (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "TIMEINIT");
return p ();
}
// TIMEREAD
// Millisekunden-Timer auslesen. Das Ergebnis ist die Anzahl der
// vergangenen Millisekunden nach Aufruf von TIMEINIT.
// Parameter: keine
// Rueckgabe: Millisekunden als Zahlenwert
DWORD timeread (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "TIMEREAD");
return p ();
}
// DELAYUS
// Verzoegerung im Mikrosekundenbereich.
// Parameter: Zeit in Mikrosekunden
// Rueckgabe: keine
int delayus (DWORD dwTime)
{
typedef int (CALLBACK* LP2INT)(DWORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "DELAYUS");
return p (dwTime);
}
// TIMEINITUS
// Setzt den Mikrosekunden-Zeitzaehler auf Null.
// Parameter: keine
// Rueckgabe: keine
int timeinitus (void)
{
typedef int (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "TIMEINITUS");
return p ();
}
// TIMEREADUS
// Mikrosekunden-Timer auslesen. Das Ergebnis ist die Anzahl der
// vergangenen Mikrosekunden nach Aufruf von TIMEINITUS.
// Parameter: keine
// Rueckgabe: Mikrosekunden als Zahlenwert
DWORD timereadus (void)
{
typedef DWORD (CALLBACK* LP2INT)();
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "TIMEREADUS");
return p ();
}
// REALTIME
// Hoechste Prioritaet einstellen. Dieser Aufruf ist bei zeitkritischen
// Ausgaben nuetzlich. Er sollte nur kurz aktiviert werden, da alle
// anderen Programme dann langsamer laufen.
// Parameter: 0 oder 1
// Rueckgabe: keine
int realtime (WORD wPriority)
{
typedef int (CALLBACK* LP2INT)(WORD);
LP2INT p; // Funktionszeiger
p = (LP2INT) GetProcAddress (hDLL, "REALTIME");
return p (wPriority);
}
#endif // PORTDLLCHEADER
Blackbird
Lesezeichen