Serial Communication Library and components for rs-232, tcp/ip communication. Data transfer and file transfer protocols ZMODEM 8k, zmodem 32k, YMODEM, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT, MODBUS, 3964, RK512, LSV2. Supporting Visual Studio NET, C#, VB Net, class library, Delphi, C++ Builder, Visual Basic. Serial Port Communication Library and components, .NET component.

Data transfer and file transfer protocols ZMODEM, YMODEM, YMODEM-G, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT, MODBUS, 3964, RK512, LSV2. Supporting Visual Studio NET, C#, VB Net, class library, Delphi, C++ Builder, Visual Basic. Serial Communication Library and components for rs-232, tcp/ip communication. Serial port communication library .NET component for Visual Studio 2003, Visual Studio 2005, Visual Studio 2008

SuperCom™

---

Serial Communications - RS-232 - Toolkit for Windows 7, Windows Vista, Windows XP/2000/Server 2003/Server 2008/NT/ME/98/95, DOS and OS/2

The data communication toolkit, SuperCom, supports data transmission through serial RS-232/422/485 ports, TCP/IP and ISDN communication layers. Though different the communication ways are, the developer use one easy to use, flexible and powerful API!

SuperCom for RS-232

Is a programer's toolkit for programming serial data communication programs.

SuperCom contains functions for all aspects of modern data transmission. Transmitting and receiving takes place in the background. The application can easily perform other tasks while data transmission takes place. The hardware or software flow control (RTS/CTS, DTR/DSR, XON/XOFF) can be taken over fully transparent by SuperCom.

Every interface runs with it's own transmit and receive buffer to prevent data loss and give the application the time to perform other tasks too.

Hardware errors are detected and if required reported.

Establishing dial-up connections is easy and it's featured directly through a Modem or using TAPI (Windows Telephony API).

^:::

ZMODEM YMODEM YMODEM-G YMODEM/BATCH XMODEM-1K XMODEM XMODEM/CRC KERMIT ASCII ---- AS511 3964R RK512 LSV/2 MODBUS

SuperCom breaks the limits in fast and reliable file transfer. It includes nearly all known standard file transfer protocols (e.g. ZMODEM, YMODEM, XMODEM, KERMIT, ASCII). Special protocol modules (e.g. MODBUS, AS511, 3964R, RK512, LSV/2) are available to support industrial data communications.

SuperCom API

SuperCom offers an easy to use, flexible and portable API. The same API is used among different operating systems and hardware (RS-232, RS-485, ISDN, TCP/IP). Under Windows it's also referred as the SuperCom DLL API.

The software developer uses one single API.

Transmitting and receiving takes place in the background. The application can easily perform other tasks while data transmission takes place.

SuperCom is fast, even in a multitasking operating system. SuperCom integrates the most modern communication technology like: event reporting, thread driven data transmission, high speed byte and paket functions. Furthermore it offers the highest security and speed with little burden on the computer, particularly important in a multitasking operating system.

Every connection runs with it's own transmit and receive buffer to prevent data loss and give the application the time to perform other tasks too.

Modularity in Data Communications

SuperCom consists of several modules which can be used according to your needs.

The core module contains the "low level functions" operating on top of the hardware and the "high level functions" offering a portable layer. This portable layer provides most wanted functions like: transmit and receive data (even time dependent), determine the status of a link, funtions that transmit and receive data packets (even time dependent), functions for calculating check sums and CRC, functions for setting up connections etc.

^:::

ZMODEM YMODEM YMODEM-G YMODEM/BATCH XMODEM-1K XMODEM XMODEM/CRC KERMIT ASCII ---- AS511 3964R RK512 LSV/2 MODBUS

The standard protocol module contain the so called Standard File Transfer Protocols. These protocols enable fast and secure file transmission with ease. Special protocol modules contain protocols mainly used in industrial applications. Protocols like MODBUS, AS511, 3964R, RK512, LSV/2 are available  (see also Software and Features).

Another module groups together the terminal emulations ANSI, TTY and VT52.

Portable

The part of your application which takes care the data communication with SuperCom can already be considered as completed if moving from Serial to TCP/IP or ISDN and especially if moving from DOS or OS/2 to Windows.

Easy Handling

Despite the large number of functions, programming with SuperCom is very easy. The following short program should clearly show this:

  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);

  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);

  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)

The function ComInit configures the interface. ComSetState initializes the serial interface "COM2" with the new transmission parameters and flow control. The function RS_TXPacket transmits the data packet Msg through the serial interface and ComReset closes all action on the serial interface and restores the previous state of the interface.

The next small sample shows an elegant solution to a common problem: What ports are available in the system (installed and not used).

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

    printf("scaning hardware...");

    for (i=COM_1; i<MAX_COM; i++)
    {
        switch (ComPortPresent(i))
        {
        case PORT_AVAILABLE_READY: wPortReady++;
             // port is not used by any application

        case PORT_AVAILABLE_BUSY: wPortCount++;
             // port is used by any application
            break;

        case PORT_UNAVAILABLE:
             // hardware is not installed
             break;
        }
    }
     
Hint: see also ComPortPresentEx

Event Driven

An application using SuperCom can be event driven. Events are reported for: received or transmitted data, modem status, line errors, modem dialup status, file transmit status.

The enhanced event reporting mechanism in SuperCom also enables you to receive events on any defined character (e.g. STX, ACK, NAK, EOF).

   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 And EV_TXCACHE_EMPTY) Then
          // ...

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

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

      If (SComEvent And 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;
   }

Connecting

Setting up connections through a Modem, TAPI, TCP/IP or ISDN is taken care by the common connect functions. The SuperCom functions can establish a connection (dialup) or waiting on an incoming call (server).

The SuperCom functions can trigger events during a connection attempt and provide the application with status information.

DLL API
In order to receive events the application must provide an InfoProc*. The InfoProc is optional but very handy in many situations. Using the InfoProc the application can receive progress information, get informed about the time left to complete a call or even cancel the connection attempt.

   int InfoProc(BYTE Com, WORD Action, DWORD TimeLeft, PVOID Data)
   {
      if (Action==acCONNECT_INFO)
      {
         // Received periodically, while in progress
      }
      if (Action==acCONNECT_OK)
      {
         // Connected !
      }
      if (Action==acCONNECT_FAILED)
      {
         // A connection attempt failed
      }

      return infContinue;

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

     // now connect ...
   Res = RS_ConnectEx(Com, SEC_60, , DialStr, 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
         'Received periodically, while in progress
      End If
      If SComAction = acCONNECT_OK  Then
         ' Connected !
      End If
      If SComAction = acCONNECT_FAILED Then
         ' A connection attempt failed
      End If

      InfoProc = infContinue

   End Function
        :
        :
     ' init  ...
   Call ComInit(Com)

     ' now connect ...
   Res = RS_ConnectEx(Com, SEC_60, ,DialStr, InfoProc)

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

      If (Action = acCONNECT_INFO) Then
      Begin
         // Received periodically, while in progress
      End;
      If (Action = acCONNECT_OK) Then
      Begin
        // Connected !
      End;
      If (Action = acCONNECT_FAILED) Then
      Begin
        // A connection attempt failed
      End;
        :
   End;
      :
      :
     // init  ...
   ComInit(Com);

     // now connect ...
   Res = RS_ConnectEx(Com, SEC_60, ,DialStr, @InfoProc);

   public int InfoProc(int Com, short Action, int Data, int Data)
   {
      switch (Action)
      {
         case SuperCom.acCONNECT_INFO:
               // Received periodically, while in progress
              break;
         case SuperCom.acCONNECT_FAILED:
               // A connection attempt failed
              break;
         case SuperCom.acCONNECT_OK:
               // Connected !
              break;
         case SuperCom.acUSERBREAK:
              // break by user
              break;
      }
      return SuperCom.infCONTINUE;
   }
      :
     // init  ...
   SuperCom.ComInit(Com);

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

Seting up a connection can run completely in background. The application receives events about the progress.

Comparing this sample made for a serial Modem with the one for TCP/IP or ISDN shows how effectiv it is to have a portable API!

File Transfer Protocols

SuperCom provides reliable and high speed file transfer protocols. These protocols are widely used and supported by many third party applications. SuperCom supports the ZMODEM, KERMIT, YMODEM/BATCH, YMODEM, YMODEM-G, XMODEM-1K, XMODEM, XMODEM/CRC and ASCII protocol. The most powerful among these protocols is ZMODEM. The ZMODEM protocol includes important features like "crash recovery", 32bit CRC, "batch file transfer", File Options, ZMODEM/8k block option and the powerfull ADONTEC extension ZMODEM/32k (ZMODEM/64k shipped on request) .

The KERMIT protocol is also a versatily protocol offering alot of options.

A file transfer is very easy started by one function. The protocol then triggers events to inform about status and other usefull protocol information. Events are received by a so called InfoProc*. The InfoProc is optional but very handy in many situation e.g. to receive progress information, to cancel a file transfer. A protocol like ZMODEM or YMODEM/BATCH can receive many files within on session. The InfoProc will provide such information.

   int COMMAPI InfoProc(BYTE Com, WORD Action, DWORD TimeLeft, PFDATA Data)
   {
      int Res=infCONTINUE;

      if (Action==acSYN)
      {
        // Synchronization
      }
      if (Action==acRXING)
      {
        // A block of data received
      }
      if (Action==acTXING)
      {
       // A block of data transmitted
      }
      if (Action==acTXFIN)
      {
       // File successfully transmitted
      }
      :
      return Res;
   }
      :
    // Transmit a file ...
   RS_TXFile_ZMODEM(Com, FName, , InfoProc);

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

      If SComAction = acSYN  Then
         'Synchronization
      End If
      If SComAction = acRXING  Then
         ' A block of data received
      End If
      If SComAction = acTXING Then
         ' A block of data transmitted
      End If
      If SComAction = acTXFIN Then
         ' File successfully transmitted
      End If

      InfoProc = infContinue

   End Function
        :
        :

     ' Transmit a file ...
   Res = RS_TXFile_ZMODEM(Com, FName, , InfoProc)

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

      If (Action = acSYN) Then
      Begin
         // Synchronization
      End;
      If (Action = acRXING) Then
      Begin
        // A block of data received
      End;
      If (Action = acTXING) Then
      Begin
        // A block of data transmitted
      End;
      If (Action = acTXFIN) Then
      Begin
        // File successfully transmitted
      End;
        :
   End;
      :
      :
     // Transmit a file ...
   Res = RS_TXFile_ZMODEM(Com, FName, , @InfoProc);

   public int InfoProc(int Com, short Action, int Data, int Data)
   {
      switch (Action)
      {
         case SuperCom.acSYN:
               // Synchronization
              break;
         case SuperCom.acRXING:
               // A block of data received
              break;
         case SuperCom.acTXING:
               // A block of data transmitted
              break;
         case SuperCom.acTXFIN:
              // File successfully transmitted
              break;
      }

      return SuperCom.infCONTINUE;
   }

      :
      :

     // Transmit a file ...
   Res = SuperCom.RS_TXFile_ZMODEM(Com, FName,,,cbXFileInfoFunc);

A file transfer is very easy started by one function. The protocol triggers events to inform about status and other usefull protocol information. Events are received by a so called InfoProc*. In order to receive events the application must provide an InfoProc*. The InfoProc is optional but enables to receive status information, if required and a better control over the happening (e.g. break a file transfer untimely).

Industrial Protocols

Additional modules supporting the industry protocols 3964, 3964R, RK512, AS511, LSV/2 and MODBUS are also available (see also Software and Features).

Custom Protocol Development

SuperCom provides a big pool of functions to easy develop custom protocols. Functions to transmit data packages i.e. event driven, time driven, functions to calculate checksums, CRC and many more.

MS Office

SuperCom supports MS-Office applications through direct function calls to the SuperCom DLL API or using the VBA (Visual Basic for Applications) calling interface.

Office applications like Access, Excel, Word may also prefer to use the ActiveX API . Another way is to call functions from the SuperCom DLL API using the available VBA (Visual Basic for Applications) calling interface.

Samples for Word and Excel are available.

The SuperCom ActiveX

The Serial Hardware

In serial communication SuperCom supports a multitude of different serial interfaces. The variety of serial interfaces is diverse and SuperCom is flexible enough to control the different variations in a transparent way hidding the details. In order to get an overview of the available types of serial interfaces and the performance spectrum of SuperCom we have divided the seerial hardware selection into the following three groups: Standard COMM Ports Multiserial boards Virtual COMM Ports Intelligent multiserial boards Standard Comm Ports Serial comm ports which do not support interrupt sharing are called Standard Comm Ports (e.g. COM1, COM2). Multiserial Boards Multiserial boards are add-on boards for PCI, PCI-X, PCIe or ISA Bus. These boards include one or more COMM ports. By design some boards allow two or more boards to run in a single PC. Virtual COMM Ports Are physically not present COMM ports. The real hardware is not available inside of this PC but is connected externaly e.g. on an Ethernet Network (e.g. PortServer, Comm Server), redirected ports through the Windows Remote Desktop Protocol (RDP), PCMCIA to Serial, USB to Serial Comm Port, Bluetooth to Serial Comm Port, Infrared to Serial or any other type of non physically present COMM port. SuperCom locates these COMM ports even if it uses non-standard COMM names (e.g. FASTCOM19). One or more multi serial boards can be installed in a PC (dependent on manufacturer) to support the amount of serial ports needed. Intelligent boards The intelligent boards are serial boards equipped with a CPU (mainly 80186 or RISC) and RAM. Intelligent boards can be equipped with 64KByte to 1MByte of dual-ported RAM mainly used for data storage and buffering. This improves the system speed and reduces the overall load of the host CPU due to the missing interrupt requests. PCMCIA (X=1/2/4) These are PCMCIA to RS-232 adapters, PCMCIA to RS-422 adapters or PCMCIA to RS-485 adapters. Some samples USB (X=1/2/4/8/16) These are USB to RS-232 adapters, USB to RS-422 adapters or USB to RS-485 adapters. Some samples FIFO Support (UART 16550/16650/16750/16950) The 16550 UART has the feature to temporarily store up to 16 incoming characters in a FIFO (First In First Out) buffer. This feature increases the performance of the system since the number of interrupts in the system is reduced. Furthermore the security of the data transmission is considerably improved, above all in a multitasking environment and high transmission speeds are possible. Modern UARTS like the 16950 are equipped with up to 128 bytes of FIFO buffer. SuperCom supports the enhanced features of the FIFO module. RS-485 Besides supporting RS-232 and RS-422 communication ports, SuperCom offers support for the RS-485 data communication. RS-485 connects two or more stations on a two wire simplex bus system. Each station can at a time only transmit or receive data (simplex). The so called "direction" is used to switch from receiving to transmit mode. SuperCom handles the RS-485 port complete transparently if enabled with the function ComRS485. A four wire duplex connection may also be used.

SuperCom DLL API - Features List           DLL API

Please note that not all features are supported by every SuperCom software package. Please consult the Content Description and the chart of Software and Features to make sure the feature you want is supported by the selected SuperCom software.

A short summary of the ActiveX API can be found here.

A short list of DLL API functions can be found here.

Check our special offer, the Serial to TCP/IP GateWay software (COMMServer, PortServer) developed with SuperCom. This is Free Bonus software (incl. source code) offered to latest SuperCom Suite owners.

Versatility

SuperCom is still the number one toolkit that supports different development environments providing extensive API support and samples. You're free to switch your compiler anytime and your are not bound to one and only. This saves a huge amount of time and costs of development._{Available Product Range - Pricelist}

Compiler, Operating System More...

Fabulous! And as always, thanks for the prompt and thorough support. You have a fan in California. Thanks!
Bob... from California