Da ich den Vorschlag mit der port.dll (gleiche Ansteuerung/Funktion wie rsapi.dll) gemacht hatte, will ich auch den Code dazu posten. Die DLLs gibt es kostenlos im Netz.

Port.h:
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