Serielle Schnittstelle Komponnente für Borland C++ Builder 6

[Blackbird]

Hier geht es weiter:

cport.h:

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

/*******************************************************************************
** 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