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

Hallo!
Bei Delphi habe ich immer ComPort verwendet.
Das funktioniert aber mit C++6 nichtmehr.
Kennt jemand eine komfortable Komponnente für Version 6?
Ich habe keine Lust alles über Windows API selber zu schreiben.

Mit ComPort war ich eigentlich sehr zufrieden, was ähnliches wäre schön.


MfG ACU

PS: Trotz umfangreicher Suche bei Google habe ich nichts gefunden.

Es gibt die port.dll von B. Kainka/H. Behrendt. Ob die nun unter Delphi, VBasic, Java oder C/C++ betrieben wird, ist ihr doch egal. Wie sie von all den Sprachen angesprochen wird, ist ebenfalls beschrieben.

Blackbird

Hallo zusammen,

hat schon mal jemand mit der port.dll und C/C++ gearbeitet? Hat mir eventuell jemand nen Beispielcode?

MfG Marco

Hallo,

ich arbeite mti dem C++ Builder 3.
er hat leider keine komponente, aber ich hab schon div. PIC Boards über die serielle schnittstelle gesteuert. das heißt, wenn du willst kannst du einen einfachen code haben (ist, finde ich, relativ leicht zu verstehen), den in ein kleines unterprogramm oder ähnliches gepackt und schon hast du dein modul. der code stammt aus meiner schulzeit (vor ca 1 - 1 1/2 jahren), sicher gibt es heutzutage leichtere lösungen

Hallo lion,

wäre super wenn du ein bisschen Code posten könntest.

MfG Marco

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

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

hiho, hier der versprochene code:

Code:

---

HANDLE h;                                    //Handlegenerierung
DCB Dcb;                                    //Objekt für Einstellung der COM Optionen
char Zeichenkette[12];
COMMTIMEOUTS Timeout;                        //Objekt für Timeout-Settings von COM1, Read und Write
h=CreateFile ("COM1", GENERIC_READ|GENERIC_WRITE,0,NULL, OPEN_EXISTING,0,NULL);
        /*Handlezuweisung für Serielle Schnittstelle (COM1"*/
if (h==INVALID_HANDLE_VALUE)                    //wenn kein Handle erhalten, Programm
{                                                // abbruch
Edit1->Text="kein Handle";
};
SetupComm (h,300,300);                              //Initialisierung von COM1
GetCommState (h,&Dcb);                              // Statusabfrage
Dcb.BaudRate=9600;                                  // Baudrate
Dcb.ByteSize=8;                                    // Wortlänge
Dcb.Parity=0;                                      // Parity Ja/Nein, hier Nein
Dcb.StopBits=0;                                    //
SetCommState (h,&Dcb);                              //"Speichern" der Einstellungen

Timeout.ReadIntervalTimeout=2000;                    //Einstellen der Timoutzeiten für
Timeout.ReadTotalTimeoutMultiplier=10;              //Read und Write
Timeout.ReadTotalTimeoutConstant=2000;
Timeout.WriteTotalTimeoutMultiplier=10;
Timeout.WriteTotalTimeoutConstant=2000;

SetCommTimeouts(h,&Timeout);

pos=1;
TransmitCommChar(h,pos);
CloseHandle (h);

---

pos is bei einfach eine zahl, die übertragen wird, du kannst immer mit

Code:

---

h=CreateFile ("COM1", GENERIC_READ|GENERIC_WRITE,0,NULL, OPEN_EXISTING,0,NULL);

---

den Handel zuweißen und it mit

Code:

---

CloseHandle (h);

---

wieder schließen.

das is der code, der aus meienr schulzeit stammt, leider sehe ich aber gerade, dass es nur schicken ist, aber eigentlich müßte es mit ReadCommChar auch funken, werde mal testen bzw ehmalige schulkollgene wegen dem empfangen schreiben

hoffe das hilft dir ein wenig weiter

gibt es hier schon etwas Neues? würde mich nämlich auch interessieren.

@Lektor: diese "createfile"/Handle geschichte ist so, wie sie ist und funzt auch .
Wie meinst du das mit "Neues" ?

wollte nur wissen ob es komplett ist. lion hat nämlich geschrieben "leider sehe ich aber gerade, dass es nur schicken ist, aber eigentlich müßte es mit ReadCommChar auch funken, werde mal testen bzw ehmalige schulkollgene wegen dem empfangen schreiben".

Der Thread ist zwar schon eine Weile her, aber ich hole ihn trotzdem mal wieder ans Licht, damit ich nicht extra einen neuen aufmachen will.

Ich benutze die WinApi Funktionen fürs senden und empfangen.
Das Problem ist, dass wenn ich ein Byte lesen lasse und noch keins im Puffer ist, das Programm solange wartet, bis es etwas empfängt.
Da ich momentan nur einen Thread habe, blockiert alles.
Ich habe das jetzt mit Timouts umgangen, ist aber auch nicht gerade die feine englische, sondern nur eine Notlösung.

Kann mir jemand eine Funktion geben, die mir zurückliefert ob, bzw. wieviele Zeichen im Com Puffer sind?
Wäre ganz toll, ich suche danach schon lange.

http://msdn.microsoft.com/library/de...sdn_serial.asp

Ich dachte an das Event Flag EV_RXCHAR.
Habe ich aber nicht weitergebracht.


MfG ACU

Ich habe das mit dem Event gemacht.
Ist in Pocket-C, sollte aber bei dir auch so gehen.

Code:

---

      do{
        commwait(ret,0);
        wind_event = event(1);
        sleep(0);
        switch(wind_event) {
        case PM_COMMEVENT: {  // Serial Port
              do {
              cc = readbyte(ret);

---

https://www.roboternetz.de/phpBB2/vi...=190767#190767

Vielen Dank!
Werde ich heute gleich mal probieren, ich sage nochmal Bescheid, obs geklappt hat.


MfG ACU