Serielle Kommunikation Bibliothek und Komponente für rs-232, tcp/ip Kommunikation. Datenübertragung und Dateiübertragungs-Protokolle ZMODEM, YMODEM,XMODEM, KERMIT, MODBUS, 3964, RK512, LSV2. Unterstützt Entwicklung mit Visual Studio für NET, C#, VB Net, Klassen bibliothek, C++ Builder, Delphi, Visual Basic.

Datenübertragung und Dateiübertragungs-Protokolle ZMODEM, YMODEM,XMODEM, KERMIT, MODBUS, 3964, RK512, LSV2. Unterstützt Entwicklung mit Visual Studio für NET, C#, VB Net, Klassen bibliothek, C++ Builder, Delphi, Visual Basic. Serielle Kommunikation Bibliothek und Komponente für rs-232, tcp/ip Kommunikation.

SuperCom™

---

Das Kommunikations-/RS-232-Toolkit für Windows Vista, Windows XP/2000/2003/NT/ME/95/98/3.x, DOS und OS/2

SuperCom für RS-232
das seit Jahren bewährte serielle Kommunikations Toolkit (RS232-Toolkit) SuperCom vereinfacht die Entwicklung von Kommunikationsprogrammen.

SuperCom beinhaltet Funktionen für alle Aspekte der modernen Datenübertragung.

Das Senden und Empfangen findet transparent im Hintergrund statt. Die Anwendung kann sehr einfach andere Aufgaben übernehmen solange die Datenübertragung läuft. Die Hardware- und Software-Flußsteuerung (RTS/CTS, DTR/DSR, XON/XOFF) wird für die Applikation völlig transparent von SuperCom übernommen.

Jede Verbindung verfügt über einen eigenen Sende- und Empfangspuffer. Damit wird ein Datenverlust unterbunden und die Anwendung erhält genug Zeit um auch andere Aufgaben zu erledigen.

Hardware-Fehler werden erkannt und auf Wunsch gemeldet.

Wählverbindungen direkt über ein Modem oder über TAPI werden unterstützt.

Fast alle bekannte Standard-Protokolle stehen für die schnelle und gesicherte Dateiübertragung bereit (z.B. ZMODEM, YMODEM, XMODEM, KERMIT, ASCII).

SuperCom API
Das SuperCom API ist einfach zu handhaben, flexibel und portabel. Das gleiche API ist unter mehreren Betriebsystemen und Kommunikations-Hardware (RS-232, RS-485, ISDN, TCP/IP) verfügbar. Unter Windows wird es auch als SuperCom DLL API beschrieben.

Der Software-Entwickler verwendet ein einfaches, flexibles und plattformübergreifendes API.

SuperCom ist schnell, auch unter einem Multitasking-Betriebssystem. SuperCom integriert modernste Kommunikationstechnik, das heißt: Ereignissteuerung, Hintergrundbetrieb, hochgeschwindigkeits Zeichen- und Block-Funktionen, FIFO-Support u.v.m. Außerdem bietet es höchste Sicherheit und Geschwindigkeit bei geringer Rechnerbelastung, vor allem wichtig unter Multitasking-Betriebssysteme.

Jede Schnittstelle bzw. Verbindung verfügt über einen eigenen Sende- und Empfangspuffer. Damit wird ein Datenverlust unterbunden und die Anwendung erhält genug Zeit um auch andere Aufgaben zu erledigen.

Modular
SuperCom besteht aus Modulen, die je nach bedarf genutzt werden können.

Den Kern von SuperCom bilden die "Low Level Funktionen", die hardwarenah operieren und die "High Level Funktionen" welche für einen sehr grossen Grad an Abstraktion sorgen.

Innerhalb dieser High Level Funktionen befinden sich Funktionen für Verbindungsaufbau, -abbau, Leitungsüberwachnung, Status-Abfragen, Funktionen die einzelne Daten oder Datenpakete senden bzw. empfangen (auch zeitabhängig), Prüfsummen berechnen, u.a.m.

In einem weiteren Modul sind die Standard Dateiübertragungs-Protokolle ZMODEM, YMODEM/BATCH, YMODEM, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT und ASCII untergebracht. Diese Funktionen gestalten die Dateiübertragung zu einer schnellen, sicheren und einfachen Sache.

Die Terminal-Emulationen ANSI, TTY und VT52 sind in einem weiteren Modul untergebracht.

Portabel
Den Teil Ihrer Applikation, der mit SuperCom die Kommunikation erledigt, können Sie bei einer eventuellen Portierung von Seriell zu TCP/IP oder ISDN und speziell von DOS oder OS/2 nach Windows schon als erledigt betrachten. Fast der gesamte Funktionsumfang von SuperCom ist in den obengenannten Platformen verfügbar, ausgenommen von einer sehr kleinen Zahl betriebssystemabhängiger Funktionen, die mit der eigentlichen Datenübertragung meistens nichts zu tun haben und selten verwendet werden.

Einfache Handhabung
Trotz der großen Anzahl an Funktionen ist die Programmierung mit SuperCom sehr einfach. Das folgende kurze Programm soll das verdeutlichen:

  char *Msg = "Hello World";

  ComInit(COM_2);

  ComSetState(COM_2, 19200, 8, 1, 'N', SIGNAL_CTS);

  RS_TXPacket(COM_2, Msg, strlen(Msg), &Result);

  ComReset(COM_2);

  

  Msg := 'Hello World';

  ComInit(COM_2);

  ComSetState(COM_2, 19200, 8, 1, 'N', SIGNAL_CTS);

  RS_TXPacket(COM_2, Msg, Length(Msg), Result);

  ComReset(COM_2);

  

  Msg = "Hello World"

  Call ComInit(COM_2)

  Call ComSetState(COM_2, 19200, 8, 1, Asc("N"), SIGNAL_CTS)

  Call RS_TXPacket(COM_2, Msg, Len(Msg), Result)

  Call ComReset(COM_2)

  

  string Msg = "Hello World";
  byte[] Buffer;

  SuperCom.ComInit(COM_2);
  SuperCom.ComSetState(COM_2, 19200, 8, 1, 'N', SIGNAL_CTS);

  Count=StringToBuffer(Msg, Buffer); // custom function
  SuperCom.RS_TXPacket(COM_2, Buffer, Count, ref Result);

  SuperCom.ComReset(COM_2);
  

Die Anweisung ComInit teilt SuperCom die Konfiguration der Schnittstelle mit. ComSetState initialisiert die serielle Schnittstelle "COM2" mit den Übertragungsparametern und die Flußsteuerung. Die Anweisung RS_TXPacket sendet das Datenpaket Msg über die serielle Schnittstelle und ComReset schließt sämtliche Aktionen auf der seriellen Schnittstelle ab und stellt den alten Zustand der Schnittstelle wieder her.

Das nächste Beispiel demonstriert eine elegante Lösung für ein nicht seltenes Problem: Die Ermittlung der installierten und im Augenblick unbenutzten Schnittstellen (auch fremde Applikationen).

    WORD wPortCount=0;
    WORD wPortReady=0;
    WORD i;

    printf("Suche nach Schnittstellen...");

    for (i=COM_1; i<MAX_COM; i++)
    {
        switch (ComPortPresent(i))
        {
        case PORT_AVAILABLE_READY: wPortReady++;
             // Schnittstelle ist verfügbar

        case PORT_AVAILABLE_BUSY: wPortCount++;
             // Schnittstelle wird von
             // anderen Anwendungen benutzt
            break;

        case PORT_UNAVAILABLE:
             // Hardware ist nicht installiert
             break;
        }
    }

Ereignis-Meldungen (Event-Funktionen)
Eine Anwendung kann mit SuperCom Ereignisgesteuert arbeiten. Dabei werden Ereignisse beim Empfang oder Versand von Daten, Änderungen der Modem-Statusleitungen, Übertragungsfehler, Statusmeldungen beim Verbindungsaufbau und während der Dateiübertragung gemeldet.
SuperCom Ereignisse können auch beim Empfang von speziellen Zeichen erzeugt werden (z.B. STX, NAK, ACK, EOF usw.). Als spezielles Zeichen kann jedes Zeichen definiert werden. Die erweiterte Ereignissteuerung im SuperCom macht es auf einfache Weise möglich.

   DWORD COMMAPI UserEventProc (BYTE Com, DWORD SComEvent)
   {
       if (SComEvent & EV_TXCACHE_EMPTY)
          // ...

       if (SComEvent & EV_RXCHAR)
          // ...

       if (SComEvent & EV_RI)
          // ...

       if (SComEvent & EV_TRIGGER)
          // ...

         :
         :
      return 0;
   }
  

   Function UserEventProc(ByVal ComId As Byte, ByVal SComEvent As Long) As Long

      UserEventProc=0

      If (SComEvent And EV_RXCHAR) Then
          // ...

      If (SComEvent And EV_TXEMPTY) Then
          // ...

      If (SComEvent And EV_RI) Then
          // ...

      If (SComEvent And EV_TRIGGER) Then
          // ...
        :
        :
   End Function
  

   Function UserEventProc(Com:Byte; SComEvent:DWORD):DWORD;
   Begin
      UserEventProc:=0; { Continue }

      If (SComEvent & EV_TXCACHE_EMPTY) Then
          // ...

      If (SComEvent & EV_RXCHAR) Then
          // ...

      If (SComEvent & EV_RI) Then
          // ...

      If (SComEvent & EV_TRIGGER) Then
          // ...
      :
      :
   End;
  

   public int UserEventProc(int Com, int SComEvent)
   {
      if ((SComEvent & SuperCom.EV_RXCHAR)==SuperCom.EV_RXCHAR)
          // ...

      if ((SComEvent & SuperCom.EV_TXCACHE_EMPTY)==SuperCom.EV_TXCACHE_EMPTY)
          // ...

      if ((SComEvent & SuperCom.EV_RI)==SuperCom.EV_RI)
          // ...

      if ((SComEvent & SuperCom.EV_TRIGGER)==SuperCom.EV_TRIGGER)
          // ...

        :
        :
      return 0;
   }
  

Verbindungsaufbau
Der Verbindungsaufbau erfolgt über spezielle Funktionen, die je nach Softwareumfang analoge Modems, TAPI Schnittstelle, ISDN Karten (CAPI) oder TCP/IP unterstützen.

DLL API
Um den Verbindungsaufbau zu überwachen, besteht die Möglichkeit eine Info-Funktion anzumelden. Diese InfoProc wird von der SuperCom Software regelmäßig aufgerufen und die Anwendung dadurch mit Zustandsinformationen versorgt.

   int InfoProc(Com, Action, TimeLeft, Data)
   {
      if (Action==acCONNECT_INFO)
      {
         // Periodisch: Verbindung im Aufbau
      }
      if (Action==acCONNECT_OK)
      {
         // Verbindung erfolgreich aufgebaut !
      }
      if (Action==acCONNECT_FAILED)
      {
         // Verbindungsaufbau hat fehlgeschlagen
      }

      return infContinue;

   }
      :
      :
     //  Klient initialisieren ...
   ComInit(Com);

     // wähle ...
   RS_Dial(Com, DialStr);

     // verbinden ...
   Done = RS_Connect(Com, SEC_60, , InfoProc);
  

   Public Function InfoProc(ByVal Com As Byte, _
                            ByVal Action As Integer, _
                            ByVal TimeLeft As Long, _
                            ByVal Data As Long) As Long

      If SComAction = acCONNECT_INFO  Then
         'Periodisch: Verbindung im Aufbau
      End If
      If SComAction = acCONNECT_OK  Then
         ' Verbindung erfolgreich aufgebaut !
      End If
      If SComAction = acCONNECT_FAILED Then
         ' Verbindungsaufbau hat fehlgeschlagen
      End If

      InfoProc = infContinue

   End Function
        :
        :
     '  Klient initialisieren ...
   Call ComInit(Com)

     ' wähle ...
   Call RS_Dial(Com, DialStr)

     ' verbinden ...
   Done = RS_Connect(Com, SEC_60, , InfoProc)
  

   Function InfoProc (Com:Byte; Action:WORD; TimeLeft:TDWORD; Data:PFDATA):Integer;
   Begin
      InfoProc:=infCONTINUE; { Continue }

      If (Action = acCONNECT_INFO) Then
      Begin
         // Periodisch: Verbindung im Aufbau
      End;
      If (Action = acCONNECT_OK) Then
      Begin
        // Verbindung erfolgreich aufgebaut!
      End;
      If (Action = acCONNECT_FAILED) Then
      Begin
        // Verbindungsaufbau hat fehlgeschlagen
      End;
        :
   End;
      :
      :
     // Klient initialisieren ...
   ComInit(Com);

     // wähle ...
   RS_Dial(Com, DialStr);

     // verbinden ...
   Done = RS_Connect(Com, SEC_60, , @InfoProc);
  

   public int InfoProc(int Com, short Action, int Data, int pNotUsed)
   {
      switch (Action)
      {
         case SuperCom.acCONNECT_INFO:
               // Periodisch: Verbindung im Aufbau
              break;
         case SuperCom.acCONNECT_FAILED:
               // Verbindungsaufbau hat fehlgeschlagen
              break;
         case SuperCom.acCONNECT_OK:
               // Verbindung erfolgreich aufgebaut!
              break;
         case SuperCom.acUSERBREAK:
              // Abbruch durch Benutzer
              break;
      }
      return SuperCom.infCONTINUE;
   }
      :
     //  Klient initialisieren ...
   SuperCom.ComInit(Com);

     // wähle ...
   SuperCom.RS_Dial(Com, DialStr);

     // verbinden ...
   Done = SuperCom.RS_Connect(Com,SuperCom.SEC_10,,,cbConnectInfoFunc);
  

Der Verbindungsaufbau kann vollkommen im Hintergrund stattfinden. Die Anwendung wird mittels Ereignisse über den Fortschritt informiert.

Vergleicht man nun dieses Beispiel für serielle Modems mit dem Beispiel für TCP/IP oder ISDN Verbindungen, zeigt sich wie effektiv ein portables API sein kann !

Dateiübertragung - Protokolle
SuperCom bietet ausgereifte und schnelle Dateiübertragungs-Protokolle. Diese Protokolle, auch als Standard-Protokolle genannt, sind sehr bekannt und ermöglichen den Datenaustausch auch unter Programmen unterschiedlicher Hersteller.

Im Lieferumfang gehören die Standard-Protokolle ZMODEM, KERMIT, YMODEM/BATCH, YMODEM, XMODEM-1K, XMODEM, XMODEM-CRC und ASCII.

Das Protokoll ZMODEM ist wohl das mächtigste unter den heute eingesetzten Standard-Protokollen. Das ZMODEM Protokoll unterstützt wichtige Optionen wie "crash recovery", 32bit CRC und "batch file transfer". Das KERMIT bietet eine änliche Funktionalität.

Der Dateitransfer mit diesen Standard-Protokollen erfolgt durch einen einfachen Funktionsaufruf. Die Funktion überträgt Datei(en) mit dem gewünschten Protokoll und ermöglicht auch einen kontinuierlichen Kontakt zwischen Protokoll und Anwendung. Dadurch ist die Anwendung jederzeit über den Zustand der Dateiübertragung informiert und kann diese bei Bedarf auch stoppen.

 int COMMAPI InfoProc(BYTE Com, WORD Action, DWORD Data, PFDATA FileData)
 {
  int Res=infCONTINUE; // weiter so ...

    if (Action==acSYN)
    {
        // Synchronisation
    }
    if (Action==acRXING)
    {
        // ein Datenblock wurde empfangen
    }
    if (Action==acTXING)
    {
       // ein Datenblock wurde übertragen
    }
    if (Action==acTXFIN)
    {
       // Datei erfolgreich übertragen
    }
    :
    :
    return Res;
 }
    :
    :
    // Sende eine Datei ...
 RS_TXFile_ZMODEM(Com, FName, , InfoProc);
  

Die Funktion InfoProc* kann bereits beim Aufruf der Dateiübertragungsfunktion im Protokoll angemeldet werden. Danach ruft das jeweilige Protokoll die InfoProc asynchron auf und teilt der Anwendung den Fortschritt der Dateiübertragung. Abhängig vom Protokoll werden auch weitere Informationen geliefert. Die InfoProc ist optional jedoch sehr nützlich z.B. wenn man die Dateiübertragung beenden möchte. Bei Protokollen wie ZMODEM oder YMODEM/BATCH können mehrere Dateien innerhalb eines Aufrufs empfangen werden. Die InfoProc liefert auch diese Information.

Industrie Protokolle
SuperCom unterstützt, über zusätzlich erhältliche Module, die Protokolle 3964, 3964R, RK512, AS511, MODBUS und LSV/2

Beim Einsatz der SuperCom Industrie Protokoll Module brauchen Sie sich um die Protokolldetails nicht zu kümmern. Synchronisation, Datenübertragung und Prüfsummen erledigen die Protokollroutinen für Sie. Von einfachen Datenpaketen bis hin zur Dateiübertragung gelangen Sie ohne ein großes oder kompliziertes API lernen zu müssen.

Beim Einsatz des SuperCom 3964 Protokoll Moduls brauchen Sie sich um die Protokolldetails nicht zu kümmern. Synchronisation, Datenübertragung und Prüfsummen erledigen die Protokollroutinen für Sie. Von einfachen Datenpaketen bis hin zur Dateiübertragung gelangen Sie ohne ein großes oder kompliziertes API lernen zu müssen.

Das Protokoll unterstützt sowohl den Master- als auch den Slave-Modus und kann mit hoher oder niedriger Priorität senden bzw. empfangen.

MS-Office
SuperCom kann unter MS-Office direkt oder über VBA (Visual Basic for Applications) aufgerufen werden.

Office Applikationen wie Access, Excel, Word etc. werden evtl. das ActiveX API bevorzugen. Alternativ kann das SuperCom DLL API mittels der enthaltenen VBA (Visual Basic for Applications) Schnittstelle angesprochen werden.

Beispiele für Word und Excel sind verfügbar.

Das SuperCom ActiveX

Die Hardware
In der seriellen Kommunikation unterstützt SuperCom eine vielzahl unterschiedlicher seriellen Schnittstellen.

Das Angebot an seriellen Schnittstellen ist vielfältig und SuperCom ist in der Lage die verschiedenen Varianten, für den Anwender transparent, zu steuern.

Damit der Anwender leichter einen überblick über diese Vielfalt an seriellen Schnittstellen und vom Leistungsspektrum von SuperCom bekommt, teilen wir das Hardwareangebot in folgende drei Gruppen ein:

Standard-Schnittstellen
Als Standard-Schnittstellen werden serielle Schnittstellen bezeichnet, die kein Interrupt-Sharing unterstützen (z.B. COM1, COM2).

Multiserielle-Schnittstellenkarten
Das sind serielle Schnittstellen auf einer Einsteckkarte für den PCI, PCI-X, PCIe oder ISA Bus. Diese Karten besitzen eine oder auch mehrere serielle Schnittstelle (1, 2, 4, 8, 16 oder auch mehr).

Abhängig vom Hersteller können eine oder mehrere Multiserielle-Schnittstellenkarten in einem PC untergebracht werden.

Virtuelle-Schnittstellen
Das sind serielle Schnittstellen, die unter Windows und im betrefenden PC nicht physikalisch present sind. Diese können an einem Ethernet Netzwerk angeschlossen sind (z.B. PortServer, CommServer), über das Windows Remote Desktop Protocol (RDP) umgeleitet, USB zu Seriell, PCMCIA zu Seriell, Bluetooth zu Seriell, Infrarot zu Seriell oder jede Art von physikalisch nicht vorhandenen Schnittstellen. SuperCom erkennt diese seriell Schnittstellen auch wenn die Namensgebung manchmal nicht dem Standard entspricht (z.B. FASTCOM19).

USB zu Seriell
Das sind USB zu RS-232 Adapter, USB zu RS-422 Adapter, USB zu RS-485 Adapter. Beispielsweise USB (X=1/2/4/8/16)

PCMCIA zu Seriell
Das sind PCMCIA zu RS-232 Adapter, PCMCIA zu RS-422 Adapter, PCMCIA zu RS-485 Adapter. Beispielsweise PCMCIA (X=1/2/4)

Intelligente Schnittstellenkarten mit eigener CPU
Intelligente Schnittstellenkarten besitzen eine eigene CPU (z.B. 80186, RISC) und RAM. Die Karten verfügen über 64Kbyte oder mehr dual-ported RAM und werden in der Regel mittels Memory Mapped I/O gesteuert.

Der Hauptrechner wird stark entlastet, da die Interruptverarbeitung vollständig von der Karte übernommen wird. Geringe CPU-Auslastung erhöht die Systemleistung. Damit ist ein hoher Durchsatz bei mehreren Kanälen gewährleistet.

FIFO-Support (16550/16650/16750/16950)
Der 16550- bzw. 16650-Baustein besitzt die Möglichkeit bis zu 16 ankommende Zeichen in einem FIFO (First In First Out) Puffer zwischen zu speichern. Diese Möglichkeit erhöht die Performance des Systems, da die Anzahl der Interrupts im System heruntergesetzt wird. Außerdem wird die Sicherheit einer Datenübertragung, vor allem in einer Multitasking-Umgebung, erheblich verbessert und es sind höhere übertragungsgeschwindigkeiten möglich.
Neuere UARTS, z.B. der 16950, besitzen einen erweiterten Puffer, der bis zu 128 Bytes FIFO-Speicher haben kann.

Die erweiterten Möglichkeiten des FIFO-Bausteins werden von SuperCom völlig ausgeschöpft.

RS-485
Neben der Unterstützung von RS-232 und RS-422 Schnittstellen, bietet SuperCom auch eine Unterstützung fur die RS-485 Schnittstelle.

Die RS-485 Verbindung ist i.d.R. eine 2-Draht-Simplex Verbindung, die entweder senden oder empfangen kann. Die Sende- und Empfangsrichtung wird über das RTS Signal umgeschaltet. Nach der Initialisierung der Schnittstelle kann mit der Funktion ComRS485 die Unterstützung eingeschaltet werden. Alle anderen SuperCom Funktionen schalten dann automatisch in die richtige Richtung um. Eine 4-Draht-Duplex Verbindung wird genauso Unterstützt.

SuperCom DLL API - Hauptmerkmale und Gemeinsame Eigenschaften         DLL API

Bitte beachten Sie, daß nicht alle Funktionen oder Protokolle in allen SuperCom Software-Paketen enthalten sind. Bitte beachten Sie die Inhaltsbeschreibung und die Tabele um sicherzustellen, daß die ausgesuchte SuperCom Software die benötigten Eigenschaften besitzt.

Eine Auszug von Funktionen aus dem DLL API ist hier.

Die Zusammenfassung des ActiveX API ist hier.

Seriell zu TCP/IP GateWay (kostenloser COMMServer, PortServer mit Quelltext).

Vielseitigkeit
SuperCom ist weiterhin das einzige Toolkit, daß die unterschiedlichsten Entwicklungsumgebungen unterstützt. Es ist nicht, wie üblich, an eine Entwicklungsumgebung festgebunden. Der Entwickler hat die Freiheit seine Entwicklungsumgebung bzw. den Compiler nach seinem aktuellem Bedarf auszuwählen. Das bedeutet eine enorme Zeit- und Kostenersparnis für die Entwicklungsabteilung.

Hardware
Passende Hardware mit 2, 4, 8, 16, 32 oder 64-Ports ist verfügbar.