SuperCom

---

Windows Server, Windows 11, Windows 10 IoT LTSC, Windows 11, Windows 10, Windows 8, Windows 7, Windows Vista, Windows Server 2008, Windows XP, Windows 2000, Windows NT, Windows ME/98/95, Linux

Serielle Kommunikation Bibliothek, Serielle Datenübertragung Software

Serielle Kommunikations Komponente für rs-232, tcp/ip Kommunikation. Serielle Datenübertragung und Dateiübertragungs-Protokolle ZMODEM, YMODEM, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT, MODBUS, 3964, RK512, LSV2. Unterstützt Entwicklung mit Visual Studio für NET, C#, VB Net, Klassen bibliothek, C++ Builder, Delphi, Visual Basic (VB6). C++ Builder, Delphi incl. Embarcadero RAD XE2 XE3 Studio.

Serielle Datenübertragung und Daten-Kommunikation

und Dateiübertragungs-Protokolle ZMODEM, YMODEM, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT, MODBUS, 3964, RK512, LSV2, Heidenhain-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.

Komponenten-Bibliothek für die serielle Kommunikation und Serielle Datenübertragung Software

SuperCom Serielle Daten-Kommunikation, Serielle Datenübertragung Software, TCP/IP Daten-Kommunikation Bibliothek, ActiveX, NET Class Windows, Linux Bibliothek, Komponente, ActiveX, Unit C#, C / C++, Delphi, Java, Pascal, Visual Basic, VB net SuperCom Suite, SuperCom Serial Library incl. MODBUS, SuperCom for TCP/IP incl. MODBUS Serielle Daten-Kommunikation, TCP/IP Daten-Kommunikation Bibliothek, ActiveX, NET Class, TCP/IP Client Server

Home ADONTEC Software Entwicklung, Serielle Daten-Kommunikation, Serielle Datenübertragung Software, TCP/IP Client Server

ADONTEC's Kommunikationslösungen SuperCom - Hauptmerkmale SuperCom DLL API - Funktionen SuperCom DEMO (Seriell RS-232/422/485, ISDN, TCP/IP) SuperCom Beispiel-Anwendungen .NET 64 Bit Windows Linux

Version 10.60 neu ! Preisliste » Produktauswahl « Rückruf

SuperCom für die Serielle Kommunikation

Das seit Jahren bewährte serielle Datenübertragungs- und Kommunikations-Toolkit SuperCom vereinfacht die Entwicklung von seriellen Kommunikations-Programmen.

Auf einfache Weise Daten vom seriellen Anschluss lesen und schreiben.

Die SuperCom Bibliothek ermöglicht die Entwicklung von seriellen Kommunikations Anwendungen. Serielle Datenübertragung Software zur Steuerung von seriellen Geräten, Modem, Barcode Scanner, Waage, SPS, GPS Empfänger, serielle Geräte in der Medizin, Kassensysteme, serielle Drucker u.s.w. Die Entwicklung von Dateiübertragungs-Programmen und Datei-Server Anwendungen.

In der SuperCom Bibliothek findet die serielle Kommunikation, d.h. das Senden und Empfangen von seriellen Daten, transparent im Hintergrund statt und die Anwendung kann gleichzeitig auch andere Aufgaben übernehmen.

Eine optimierte, schnelle, vielseitige und nicht blockierende Low-Level-Datenkommunikation-Engine generiert kurze Reaktionszeiten, erzeugt und meldet Ereignisse (Events), verarbeitet Daten-Trigger, Daten-Monitoring und viele andere intelligente Datenvorverarbeitungsfunktionen (siehe Datenpakete-Sammler, Trigger und DataFilter weiter unten).

Die serielle Kommunikations Bibliothek steuert die Hardware- und Software-Flußsteuerung für die Applikation völlig transparent im Hintergrund (z.B. RTS/CTS, DTR/DSR, XON/XOFF). Bei Bedarf, auch in Kombination. Fehler auf der Datenleitung (UART/Hardware-Fehler) werden erkannt und auf Wunsch gemeldet.

Unabhängig ob OnBoard serielle Schnittstelle, Multi-Serielle Karte, drahtlose Anbindung (z.B. Bluetooth, Wireless), USB oder Ethernet basierender serieller Adapter / Konverter, SuperCom versorgt die Anwendung mit Daten präzise und zeitgleich.

Wählverbindungen direkt über ein Modem oder über das Windows TAPI (Windows Telephony API) werden unterstützt.

Mit SuperCom kann die Anwendung schneller und geschmeidiger arbeiten.

Unabhängig wie die Anwendung die Daten übermittelt, SuperCom wickelt die Datenkommunikation über mehrere Verbindungen gleichzeitig und im Hintergrund ab. Aufbau und Verwaltung von mehreren gleichzeitigen Verbindungen, lang andauerende Aufgaben können im Hintergrund ausgeführt werden. Die schnelle Ausführung und Intelligente Funktionen wie Datenpakete-Sammler, Trigger u.a. ermöglichen flexible Lösungswege.

Ob Datenaufzeichnung und -überwachung, komplizierte Datenpakete empfangen, komplexe Daten-Übertragungsprotokolle, Verbindungen aufbauen oder Dateiübertragungen. Es kann komplexe Aufgaben optimiert und transparent im Hintergrund ausführen und die Anwendung hat die Zeit sich auch für andere Aufgaben zu kümmern.

Ansteuerung, auslesen und ansprechen von seriellen Schnittstellen zum Beispiel per C, C++, C#, Delphi, Pascal, Visual Basic, Java und andere Compiler.

Mit SuperCom sind die oben erwähnten Protokolle nicht auf die serielle Kommunikation beschränkt sondern können mit jeder Verbindung genutzt werden, die von der genutzten SuperCom Bibliothek unterstützt wird z.B. ISDN, TCP/IP.

Einfache Handhabung

SuperCom ist eine universelle Kommunikations Bibliothek. Mit wenigen Funktionen steht schon ein serielles Kommunikations Programm in wenigen Zeilen. Das folgende kurze Programm verdeutlicht es:

  char *Msg = "Hello World";

  ComInit(COM_2);

  ComSetState(COM_2, 57600, 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, 57600, 8, 1, 'N', SIGNAL_CTS);

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

  ComReset(COM_2);

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

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

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

  SuperCom.ComReset(COM_2);

  String Msg = "Hello World";
  byte[] Buffer = Msg.getBytes();

  SuperCom.ComInit(COM_2);

  SuperCom.ComSetState(COM_2, 57600, DATA_BITS_8, STOP_BIT_1, PARITY_NONE, SIGNAL_CTS);

  SuperCom.RS_TXPacket(COM_2, Buffer, Buffer.length, Result);

  SuperCom.ComReset(COM_2);

  Msg = "Hello World"

  Call ComInit(COM_2)

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

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

  Call ComReset(COM_2)

Die Anweisung ComInit belegt im SuperCom den, über den Parameter Com angegebenen, Datenkanal. ComSetState initialisiert den Datenkanal (z.B. die serielle Schnittstelle "COM2" unter Windows oder "ttyS1" unter Linux) mit den Übertragungsparametern und die Flußsteuerung. Die Anweisung RS_TXPacket sendet das Datenpaket Msg über den Datenkanal und ComReset beendet sämtliche Aktionen auf den Datenkanal und gibt den Datenkanal sowie alle benutzten Hardware- und Software-Ressourcen frei.

Mehr Beispiele zum Verbindungsaufbau finden Sie hier.

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;
        }
    }
     
Tipp: siehe auch ComPortPresentEx

Die Serielle Hardware
 

Das SuperCom, für die serielle Kommunikation, unterstützt eine vielzahl unterschiedlicher serieller Hardware. Das Angebot an seriellen Schnittstellen ist vielfältig und SuperCom ist in der Lage die verschiedenen Varianten, für den Anwender transparent, zu steuern. Das aktuelle Angebot an serieller Hardware wird überschaubar, wenn wir es, funktionsgemäß, in die folgenden Gruppen unterteilen: Standard-Schnittstellen Multiserielle-Schnittstellenkarten Virtuelle-Schnittstellen Schnittstellenkarten mit eigener CPU (Intelligente Karten) Die differenzierte Behandlung der Hardware wird natürlich von SuperCom vollständig übernommen und bleibt für die Anwendung völlig transparent. 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 ISA, PCI, PCI-X oder PCIe 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. PCMCIA zu Seriell Das sind PCMCIA zu RS-232 Adapter, PCMCIA zu RS-422 Adapter oder PCMCIA zu RS-485 Adapter. 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. Virtuelle-Schnittstellen Das sind serielle Schnittstellen, die unter Windows und im betreffenden PC nicht physikalisch vorhanden sind sondern über Treiber simuliert werden. Diese können an einem Ethernet Netzwerk angeschlossen sein (z.B. PortServer, COMM Server, Terminal Server oder Serial Server), über das Windows Remote Desktop Protocol (RDP) umgeleitet, USB-zu-Seriell, Ethernet-zu-Seriell, PCMCIA-zu-Seriell, Bluetooth-zu-Seriell, Infrarot-zu-Seriell oder jede andere Art von physikalisch nicht vorhandenen seriellen Schnittstellen. SuperCom erkennt diese serielle Schnittstellen auch wenn die Namensgebung nicht dem Standard entspricht (z.B. FASTCOM19). USB zu Seriell Das sind USB zu SeriellAdapter (RS-232, RS-422 oder RS-485) verbunden an einem USB Port. SuperCom für Windows kann Ereignis mit dem Schnittstellennamen erzeugen, sobald die serielle Schnittstelle angeschlossen bzw. abgezogen wurder. SuperCom optimiert den Datendurchsatz und die Latenzzeit bei diesen Adaptern, soweit wie möglich. Als SuperCom Kunde können Sie auch das Data Transfer Optimization Guide (PDF), auf Anfrage, erhalten. Ethernet zu Seriell Das sind Ethernet zu Seriell Adapter (RS-232, RS-422 oder RS-485) verbunden im TCP Netzwerk am Switch oder Hub. SuperCom optimiert den Datendurchsatz und die Latenzzeit bei diesen Adaptern, soweit wie möglich. Als SuperCom Kunde können Sie das Data Transfer Optimization Guide (PDF), auf Anfrage, erhalten. Wireless zu Seriell Das sind serielle Schnittstellen zur drahtlosen Anbindung serieller Geräte. Der Anschluß erfolgt über einen Bluetooth-zu-Seriell, Infrarot-zu-Seriell usw. SuperCom für Windows kann Ereignis mit dem Schnittstellennamen erzeugen, sobald die serielle Schnittstelle angeschlossen bzw. abgezogen wurde. SuperCom optimiert den Datendurchsatz und die Latenzzeit bei diesen Adaptern, soweit wie möglich. Als SuperCom Kunde können Sie das Data Transfer Optimization Guide (PDF), auf Anfrage, erhalten. 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 (UART 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 für die RS-485 Schnittstelle. RS-485 Verbindet zwei oder mehrere Stationen über ein 2-Draht halpduplex Netzwerk. Die Stationen können zur einer bestimmten Zeit entweder senden oder empfangen (Half-Duplex). Die gerade aktive "Richtung" bestimmt ob eine Station gerade senden oder empfangen kann. Die zeitgerechte Umschaltung der "Richtung" is notwendig damit eine Station von Senden auf Empfang und umgekehrt, ohne Datenverlust, schalten kann. SuperCom unterstützt die RS-485 Schnittstelle und arbeitet dabei transparent und mit sehr kurzen Umschaltezeiten (mehr ...). Eine 4-Draht vollduplex Verbindung wird auch unterstützt. Die Test-Beispiele zeigten, dass SuperCom mehrere Male innerhalb von 1 ms umschalten kann. Diese Geschwindigkeitsmessung wurde mit Desktop PCs mit AMD Athlon 64 X2 2.5GHz und Windows XP SP3 ausgeführt. Neue AMD oder Intel CPUs können 2-10 mal schneller arbeiten. 9-Bit serielle Daten Serielle Daten-Kommunikation mit 9-Bit Daten-Rahmen (9-Bit Framing) wird z.B. verwendet um das Adressen-Telegramm in einem RS-485 Netzwerk oder auch bei standard RS-232 Verbindung zu erkennen. 9-Bit Daten-Rahmen werden in der Regel vom PC UART nicht unterstützt sondern von der SuperCom Software simuliert. Eine sehr schnelle Reaktionszeit ist hier besonders wichtig um eine verlässliche Datenkommunikation zu erzielen. SuperCom bietet eine verlässliche Lösung hierfür zur Nutzung mit höheren Programmiersprachen. Mehrere Beispiele (z.B. C/C++, C#, Delphi, Pascal, VB net) demonstrieren diesen Kommunikations-Modus. Beispiel Übertragung, Datenpaket mit 9-Bit Adresse: TXPacket9BitCond(Com, cData, nDataCount, SEC0_1); Die 9-Bit-Datenkommunikation wird heute u.a. zur Steuerung kleiner Embedded Controller mit spezifischen 9-Bit Protokollen (z.B. SAS-Protokoll und andere) verwendet. 9-Bit Beispiele, Klient und Server, sind verfügbar (C, C++, C#, Delphi, Pascal, VB net). Mehr

F: Die seriellen Daten, welche asynchron übertragen werden, bestehen u.a. aus Datenbits und Start-/Stop-Bits. Stellt SuperCom sicher, dass alle Bits richtig empfangen werden ?

A: SuperCom empfängt und sendet alle Bits der seriellen Daten ordnungsgemäß und transparent (ohne das Zutun der Anwendung) und dabei vollständig im Hintergrund. So sorgt SuperCom für einen stabilen und reibungslosen Datenfluß ohne dabei die Anwendung zu blockieren. Dadurch wird ein sehr hoher Datendurchsatz erreicht und Datenverluste vermieden. Dasselbe gilt auch für andere mögliche Übertragungswege z.B. TCP/IP, ISDN, Modem etc.

Das 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 - oft löst es Probleme wo andere System-Treiber einsetzen.

SuperCom integriert modernste Kommunikationstechnik, das heißt: Ereignissteuerung, Hintergrundbetrieb, hochgeschwindigkeits Zeichen- und Block-Funktionen, intelligente Datenfilter, Daten-Trigger und Datenpacket Kollektoren u.v.m. Außerdem bietet es höchste Sicherheit und Geschwindigkeit bei geringer Rechnerbelastung, vor allem wichtig unter Multitasking-Betriebssysteme.

Das Senden und Empfangen findet sicher und transparent im Hintergrund statt. Mehrere Aufgaben können der Bibliothek zur Ausführung im Hintergrund abgegeben werden. Die Anwendung kann solange andere Aufgaben nachgehen und SuperCom meldet sich, in der Regel, per Ereignis(se).

Modulare Datenkommunikation

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.

Das Terminal-Emulation Modul bietet ANSI, VT100, VT52, TTY.

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 zwischen DOS, Linux, OS/2, 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.

Ereignis-Meldungen (Event-Funktionen)

Eine Anwendung kann mit SuperCom Ereignisgesteuert arbeiten. Ereignisse werden z.B. gemeldet beim Empfang oder Versand von Daten, Änderungen der Modem-Statusleitungen, Übertragungsfehler, Statusmeldungen beim Verbindungsaufbau und während der Dateiübertragung, Anschliessen oder Abziehen von seriellen PnP Schnittstellen, Ausfall im TCP/IP Netzwerk, usw.
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.

Typ und Anzahl der Ereignisse ist auch abhängig von der eingesetzten SuperCom Software, d.h. ein SuperCom Paket für die serielle Kommunikation wird keine TCP/IP Netzwerk Ereignisse melden.

       // optionale Ereignis-Funktion
   DWORD COMMAPI OnComm (Com, SComEvent)
   {
       if (SComEvent & EV_TXCACHE_EMPTY)
          // ...

       if (SComEvent & EV_RXCHAR)
          // ...

       if (SComEvent & EV_RI)
          // ...

       if (SComEvent & EV_TRIGGER)
          // ...

         :
         :
      return 0;
   }
      :
      :
     // init  ...
   ComInit(Com);

     // aktiviere Ereignismeldung ...
   ComGetSetEventProc(Com, OnComm);
  

       ' optionale Ereignis-Funktion
   Function OnComm(Com, SComEvent) As Long

      OnComm = 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
      :
      :
     // init  ...
   ComInit(Com);

     // aktiviere Ereignismeldung ...
   ComGetSetEventProc(Com, OnComm);
  

       // optionale Ereignis-Funktion
   Function OnComm(Com, SComEvent):DWORD;
   Begin
      OnComm := 0; { Continue }

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

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

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

      If (SComEvent AND EV_TRIGGER) Then
          // ...
      :
      :
   End;
      :
      :
     // init  ...
   ComInit(Com);

     // aktiviere Ereignismeldung ...
   ComGetSetEventProc(Com, OnComm);
  

       // optionale Ereignis-Funktion, direkte SuperCom class
   public int OnComm(Com, 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;
   }
      :
      :
     // init  ...
   SuperCom.ComInit(Com);

     // aktiviere Ereignismeldung ...
   SuperCom.ComGetSetEventProc(Com, OnComm);
  

       // optionale Ereignis-Funktion
  public int OnComm(int Com, int SComEvent) {

    if (SuperCom.IsBitSet(SComEvent, SuperCom.EV_RXCHAR))
      // ...

    if (SuperCom.IsBitSet(SComEvent, SuperCom.EV_TXCACHE_EMPTY))
      // ...

    if (SuperCom.IsBitSet(SComEvent, SuperCom.EV_TRIGGER))
      // ...

    if (SuperCom.IsBitSet(SComEvent, SuperCom.EV_RI))
      // ...

    :
    :
    return 0;
  }

      :
      :
    // init  ...
  SuperCom SCom = new SuperCom(SuperCom.COM_1);

  SuperCom.ComInit();

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 OnConnect wird von der SuperCom Software regelmäßig aufgerufen und die Anwendung dadurch mit Zustandsinformationen versorgt. Die OnConnect ist optional und ermöglicht die Anzeige von Status Information und eine direkte Kontrolle des Geschehens, soweit es erfoderlich ist.

       // optionale Ereignis-Funktion
   int OnConnect(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
      }
      if (Action == acCONNECT_USERBREAK)
      {
         // Abbruch durch Benutzer
      }

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

     // verbinden ...
   Res = RS_ConnectEx(Com, SEC_60, ,DialStr, OnConnect);

       ' optionale Ereignis-Funktion
   Public Function OnConnect(Com, Action, TimeLeft, Data) 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

      If (Action = acCONNECT_USERBREAK) Then
         ' Abbruch durch Benutzer
      End If

      OnConnect = infContinue

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

     ' verbinden ...
   Res = RS_ConnectEx(Com, SEC_60, ,DialStr, OnConnect)

       // optionale Ereignis-Funktion
   Function OnConnect (Com, Action, TimeLeft, Data):Integer;
   Begin
      OnConnect:=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;
      If (Action = acCONNECT_USERBREAK) Then
      Begin
         // Abbruch durch Benutzer
      End;
   End;
      :
      :
     // Klient initialisieren ...
   ComInit(Com);

     // verbinden ...
   Res = RS_ConnectEx(Com, SEC_60, ,DialStr, @OnConnect);

       // optionale Ereignis-Funktion
   public int OnConnect(Com, Action, TimeLeft, Data)
   {
      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);

     // verbinden ...
   Res = SuperCom.RS_ConnectEx(Com,SuperCom.SEC_10,,DialStr,cbConnectInfoFunc);

       // optionale Ereignis-Funktion
   public int OnConnect(Com, Action, TimeLeft, Data) {
      switch (Action)
      {
         case SuperCom.acCONNECT_INFO:
               // Periodisch: Verbindung im Aufbau
              break;

         case SuperCom.acCONNECT_FAILED:
               // A connection attempt failed
              break;

         case SuperCom.acCONNECT_OK:
               // Verbindungsaufbau hat fehlgeschlagen
              break;

         case SuperCom.acUSERBREAK:
              // Abbruch durch Benutzer
              break;
      }
      return SuperCom.infCONTINUE;
   }

      :
    // init  ...
  SuperCom SCom = new SuperCom(SuperCom.COM_1);
  SuperCom.ComInit();
    // verbinden ...
  SCom.Connect(true,DialString);

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 !

Mehr Beispiele zum Verbindungsaufbau finden Sie hier.

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, YMODEM/BATCH, YMODEM, YMODEM-G, XMODEM-1K, XMODEM, XMODEM-CRC, KERMIT, Extended XMODEM und ASCII.

Diese Protokolle können mit SuperCom gleichzeitig auf jeder seriellen Schnittstelle oder aufgebaute Verbindung (z.B. Modem, TCP, ISDN) auch im Hintergrund ausgeführt werden. Warteschlangen (Queues) mit Dateien können erzeugt und beobachtet werden (z.B. Datei Server etc.).

Das ZMODEM Protokoll ist wohl das mächtigste unter den heute eingesetzten Standard-Protokollen. Das ZMODEM Protokoll unterstützt wichtige Optionen wie "crash recovery", 32bit CRC, "batch file transfer", Datei Optionen, ZMODEM/8k Block Option und die dynamische ADONTEC Erweiterung ZMODEM/32k (ZMODEM/64k auf Anfrage) . Die SuperCom ZMODEM implementierung bietet auch Optionen für langsame Übertragungswege und Verbindungen mit langen Reaktionszeiten (= lange Wartezeit z.B. bei Satelliten-Strecken).

Autodownload
ist die Möglichkeit automatisch Datei(en) zu empfangen, die ein entfernter Host sendet. SuperCom ermöglicht Autodownload mit den Protokollen ZMODEM, KERMIT und Extended XMODEM.

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 mittels der OnFile Ereignis-Funktion. Dadurch ist die Anwendung jederzeit über den Zustand der Dateiübertragung informiert und kann diese bei Bedarf auch stoppen. Wenn SuperCom die Protokolle wie ZMODEM oder YMODEM/BATCH nutzt kann es auch mehrere Dateien innerhalb einer Sitzung empfangen. OnFile informiert darüber.

       // optionale Ereignis-Funktion
   int COMMAPI OnFile(Com, Action, DataCount, 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, , OnFile);
  

       ' optionale Ereignis-Funktion
   Public Function OnFile(Com, Action, DataCount, FileData) As Long

      If Action = acSYN  Then
         'Synchronisation
      End If
      If Action = acRXING  Then
         ' ein Datenblock wurde empfangen
      End If

      If Action = acTXING Then
         ' ein Datenblock wurde übertragen
      End If

      If Action = acTXFIN Then
         ' Datei erfolgreich übertragen
      End If
        :

      OnFile = infContinue

   End Function
        :
        :

     ' Sende eine Datei ...
   Res = RS_TXFile_ZMODEM(Com, FName, , OnFile)
  

       // optionale Ereignis-Funktion
   Function OnFile (Com, Action, DataCount, FileData):Integer;
   Begin
      OnFile:=infCONTINUE; { Continue }

      If (Action = acSYN) Then
      Begin
         // Synchronisation
      End;
      If (Action = acRXING) Then
      Begin
        // ein Datenblock wurde empfangen
      End;
      If (Action = acTXING) Then
      Begin
        // ein Datenblock wurde übertragen
      End;
      If (Action = acTXFIN) Then
      Begin
        // Datei erfolgreich übertragen
      End;
        :
   End;
      :
      :
     // Sende eine Datei ...
   Res = RS_TXFile_ZMODEM(Com, FName, , @OnFile);
  

       // optionale Ereignis-Funktion, direkte SuperCom class
   public int OnFile(Com, Action, DataCount, FileData)
   {

      switch (Action)
      {
         case SuperCom.acSYN:
               // Synchronisation
              break;
         case SuperCom.acRXING:
               // ein Datenblock wurde empfangen
              break;
         case SuperCom.acTXING:
               // ein Datenblock wurde übertragen
              break;
         case SuperCom.acTXFIN:
              // Datei erfolgreich übertragen
              break;
         :
      }

      return SuperCom.infCONTINUE;
   }
      :
      :
     // Sende eine Datei ...
   Res = SuperCom.RS_TXFile_ZMODEM(Com, FName,,,cbOnFileInfoFunc);
  

       // optionale Ereignis-Funktion
   public int OnFile(Com, Action, DataCount, FileData)
   {

      switch (Action)
      {
         case SuperCom.acSYN:
               // Synchronisation
              break;
         case SuperCom.acRXING:
               // ein Datenblock wurde empfangen
              break;
         case SuperCom.acTXING:
               // ein Datenblock wurde übertragen
              break;
         case SuperCom.acTXFIN:
              // Datei erfolgreich übertragen
              break;
         :
      }

      return SuperCom.infCONTINUE;
   }
      :
      :
     // Sende eine Datei ...
   SCom.RS_TXFileEx(SuperCom.PROTOCOL_ZMODEM, Filename, pOnFileProc);

Die Funktion OnFile* kann bereits beim Aufruf der Dateiübertragungsfunktion im Protokoll angemeldet werden. Danach ruft das jeweilige Protokoll die OnFile asynchron auf und teilt der Anwendung den Fortschritt der Dateiübertragung. Abhängig vom Protokoll werden auch weitere Informationen geliefert.

Die OnFile ist optional und ermöglicht die Anzeige von Status Information und eine direkte Kontrolle des Geschehens, soweit es erfoderlich ist (z.B. wenn man die Dateiübertragung vorzeitig beenden möchte). Bei Protokollen wie ZMODEM oder YMODEM/BATCH können mehrere Dateien innerhalb eines Aufrufs empfangen werden. Die OnFile liefert auch diese Information.

Industrie Protokolle

SuperCom unterstützt, über separate Module, die Industrie Protokolle 3964, 3964R, RK512, AS511, MODBUS, LSV2, Heidenhain TNC Protokoll  (siehe auch unterstützte Pakete).

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.

Eigene Protokolle

SuperCom bietet verschiedene Funktionen um auf einfachste Weise, zeitgesteuerte und paketorientierte Protokolle aufzubauen. Funktionen für Zeitgesteuerte Telegrammübertragung, Berechnung von Prüfsummen erleichtern die Entwicklung.

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

Vielseitigkeit

SuperCom ist weiterhin das einzige Toolkit, daß die unterschiedlichsten Entwicklungsumgebungen unterstützt. Der Software-Entwickler hat die Freiheit seine Entwicklungsumgebung bzw. den Compiler nach seinem aktuellem Bedarf auszuwählen. Das bedeutet eine enorme Zeit- und Kostenersparnis.

Lieferumfang - Preise

Hardware

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

Lizenzbedingungen

Compiler, Betriebssysteme