Hier geht es weiter:
cport.h:
Code:
#ifndef CPORTDLLCHEADER
#define CPORTDLLCHEADER
#include <windows.h>
//#define THEDLL "RSAPI.DLL"
#define THEDLL "PORT.DLL"
/*******************************************************************************
** C/C++ -Class-Definitionen fuer die DLL "port.dll"
*******************************************************************************/
class CPORT
{
public:
CPORT ()
{
loaddll (THEDLL);
};
~CPORT ()
{
FreeLibrary (hDLL);
};
// Messagebox
bool mes (char * string)
{
MessageBox (GetActiveWindow (), string, "DLLTEST", MB_OK | MB_ICONINFORMATION);
return (true);
};
// 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);
};
private:
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);
};
HINSTANCE hDLL;
};
#endif // CPORTDLLCHEADER
Eine Beispielanwendung in C:
Code:
/*******************************************************************************
** Beispielanwendung für "PORT.DLL" und "RSAPI.DLL"
*******************************************************************************/
#include "port.h"
#include "cport.h"
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
int i;
BOOL b;
WORD wDsr, wCts, wRi, wDcd, w;
DWORD d, dX, dY, dZ, dR, dU, dV, dButton;
char s[256];
//////////// C-like mit port.h //////////////////////
if (loaddll (THEDLL))
{
// Serielle Schnittstelle(n):
i = opencom ("COM2:19200,N,8,1");
wsprintf (s, "OpenCom COM2:19200,N,8,1 liefert: %d", i);
mes (s);
i = readbyte (); // Byte an RxD lesen (wenn vorhanden)
wsprintf (s, "Readbyte liefert: %d", i);
mes (s);
sendbyte (0x55); // ein Byte ueber TxD senden
wDsr = dsr (); // Leitungen abfragen
wCts = cts ();
wRi = ri ();
wDcd = dcd ();
wsprintf (s, "DSR: %d\r\nCTS: %d\r\nRI: %d\r\nDCD: %d", wDsr, wCts, wRi, wDcd);
mes (s);
rts (1); // Leitungen setzen
dtr (1);
txd (1);
b = closecom ();
wsprintf (s, "CloseCom liefert: %d", b);
mes (s);
// Soundkarte:
i = soundis ();
wsprintf (s, "SoundIs liefert: %d", i);
mes (s);
soundcapin ();
soundcapout ();
w = soundgetrate ();
wsprintf (s, "SoundGetRate liefert: %d", w);
mes (s);
w = soundgetbytes ();
wsprintf (s, "SoundGetBytes liefert: %d", w);
mes (s);
d = soundbusy ();
wsprintf (s, "SoundBusy liefert: %d", d);
mes (s);
// Joystick:
dX = joyx ();
dY = joyy ();
dZ = joyz ();
dR = joyr ();
dU = joyu ();
dV = joyv ();
dButton = joybutton ();
wsprintf (s, "JoyX: %d\r\nJoyY: %d\r\nJoyZ: %d\r\nJoyR: %d\r\nJoyU: %d\r\nJoyV: %d\r\nJoyButton: %d",
dX, dY, dZ, dR, dU, dV, dButton);
mes (s);
// oder
joystick (&dX, &dY, &dZ, &dR, &dU, &dV, &dButton);
wsprintf (s, "JoyX: %d\r\nJoyY: %d\r\nJoyZ: %d\r\nJoyR: %d\r\nJoyU: %d\r\nJoyV: %d\r\nJoyButton: %d",
dX, dY, dZ, dR, dU, dV, dButton);
mes (s);
// Timer:
timeinit (); // Millisekundenzaehler auf 0 setzen
// irgendwas machen
d = timeread (); // seit timeinit vergangene Millisekunden lesen
wsprintf (s, "TimeRead liefert: %d", d);
mes (s);
timeinitus (); // Mikrosekundenzaehler auf 0 setzen
// irgendwas machen
d = timereadus (); // seit timeinit vergangene Mikrosekunden lesen
wsprintf (s, "TimeReadUs liefert: %d", d);
mes (s);
freedll ();
//////////// C++ -like mit cport.h //////////////////////
CPORT cp;
i = cp.opencom ("COM2:19200,N,8,1");
wsprintf (s, "OpenCom COM2:19200,N,8,1 liefert: %d", i);
cp.mes (s);
i = cp.readbyte (); // Byte an RxD lesen (wenn vorhanden)
wsprintf (s, "Readbyte liefert: %d", i);
cp.mes (s);
cp.sendbyte (0x55); // ein Byte ueber TxD senden
wDsr = cp.dsr (); // Leitungen abfragen
wCts = cp.cts ();
wRi = cp.ri ();
wDcd = cp.dcd ();
wsprintf (s, "DSR: %d\r\nCTS: %d\r\nRI: %d\r\nDCD: %d", wDsr, wCts, wRi, wDcd);
cp.mes (s);
cp.rts (1); // Leitungen setzen
cp.dtr (1);
cp.txd (1);
b = cp.closecom ();
wsprintf (s, "CloseCom liefert: %d", b);
cp.mes (s);
// Soundkarte:
i = cp.soundis ();
wsprintf (s, "SoundIs liefert: %d", i);
cp.mes (s);
cp.soundcapin ();
cp.soundcapout ();
w = cp.soundgetrate ();
wsprintf (s, "SoundGetRate liefert: %d", w);
cp.mes (s);
w = cp.soundgetbytes ();
wsprintf (s, "SoundGetBytes liefert: %d", w);
cp.mes (s);
d = cp.soundbusy ();
wsprintf (s, "SoundBusy liefert: %d", d);
cp.mes (s);
// Joystick:
dX = cp.joyx ();
dY = cp.joyy ();
dZ = cp.joyz ();
dR = cp.joyr ();
dU = cp.joyu ();
dV = cp.joyv ();
dButton = cp.joybutton ();
wsprintf (s, "JoyX: %d\r\nJoyY: %d\r\nJoyZ: %d\r\nJoyR: %d\r\nJoyU: %d\r\nJoyV: %d\r\nJoyButton: %d",
dX, dY, dZ, dR, dU, dV, dButton);
cp.mes (s);
// oder
cp.joystick (&dX, &dY, &dZ, &dR, &dU, &dV, &dButton);
wsprintf (s, "JoyX: %d\r\nJoyY: %d\r\nJoyZ: %d\r\nJoyR: %d\r\nJoyU: %d\r\nJoyV: %d\r\nJoyButton: %d",
dX, dY, dZ, dR, dU, dV, dButton);
cp.mes (s);
// Timer:
cp.timeinit (); // Millisekundenzaehler auf 0 setzen
// irgendwas machen
d = cp.timeread (); // seit timeinit vergangene Millisekunden lesen
wsprintf (s, "TimeRead liefert: %d", d);
cp.mes (s);
cp.timeinitus (); // Mikrosekundenzaehler auf 0 setzen
// irgendwas machen
d = cp.timereadus (); // seit timeinit vergangene Mikrosekunden lesen
wsprintf (s, "TimeReadUs liefert: %d", d);
cp.mes (s);
return 1;
}
return 0;
}
Ist nicht getestet. Ich verwende in C/C++ das Windows-API mit CreateFile, WriteFile, ReadFile, ...
Wenn es Dich interessiert, habe ich auch dazu Beispiel-Code (getestet).
Blackbird
Zitieren
Berechtigungen
Lesezeichen