SuperCom

---

Serial Communication Library - RS-232 - Toolkit for
Windows 7, Windows Vista, Windows Server 2008, Windows XP, Windows Server 2003, Windows 2000, Windows NT, Windows ME/98/95

Data Communication Solutions by ADONTEC SuperCom - Features List SuperCom DLL API - Functions SuperCom DEMO (Serial RS-232/422/485, ISDN, TCP/IP) .NET       64 Bit       Abstract

Version 7.5 Price List Product Range Call Me Back Translate

SuperCom - Serial Communication Library

The SuperCom Serial Communication Library is a programer's library used to develop serial communication applications.

Using SuperCom you easily write serial communication applications and control serial ports, Modem, Barcode Scanner, Scales, PLC, GPS receiver, POS, serial medical devices, serial printer etc. Develop easily applications to accomplish serial data and file transfer incl. file server applications.

With the SuperCom Serial Communication Library transmitting and receiving serial data takes place in the background enabling the application to perform other tasks while serial data transmission takes place.

Setup and handle concurrently multiple connections, run lengthly jobs in background (for example: connect, file transfer, collect data packets, trigger events), execute fast with low latency and consume less is what SuperCom was made for from it's first day.

The SuperCom Serial Communication Library offers fully transparent handshaking flow control (e.g. RTS/CTS, DTR/DSR, XON/XOFF) and combinations. Possible errors on the data line (UART/Hardware Errors) are detected and, if required, reported.

You freely use any onboard serial ports, multi serial ports cards, wireless serial adapter (e.g. Bluetooth), USB or Ethernet based serial adapter / converter etc. SuperCom delivers data accurate and fast.

Establish reliable connections in background for fast, accurate data communications and file transfers. Establishing dial-up connections is easy and it's featured directly through a Modem or using TAPI (Windows Telephony API).

No matter how the application is transmitting data, SuperCom will always perform data communication on multiple connections concurrently and in background.

Easy Handling

SuperCom is a universal communication library. Using only few functions you already get a complete serial communication program within few lines. The following short program clearly shows this for serial communications:

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

  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)

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 serial 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

The Serial Hardware
 

SuperCom's serial communication library supports a multitude of different serial hardware used for serial communications. 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 fact it's under continous tests with serial devices from major manufacturer (e.g. Axxon, Decision, Digi, Moxa, Quatech, etc.). In the following we functionally group the serial hardware actually on market as follows: Standard Serial Ports Multiserial Boards Virtual Serial Ports Intelligent Multiserial Boards Standard Serial 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 ISA, PCI, PCI-X or PCIe Bus. These boards used in serial communications and offer one or more serial ports. By design some boards allow two or more boards to run in a single PC. Controlling more than one serial communication link simultaneously is SuperCom's playground and it does it completely in background. Virtual Serial Ports With serial communication the serial port is often not physically present on the local computer but simulated by a driver. The real hardware (if any) is connected externaly e.g. on an Ethernet Network (e.g. PortServer, Comm-Server, Terminal Server or Serial Server), serial ports redirected through the Windows Remote Desktop Protocol (RDP), PCMCIA-to-Serial, USB-to-Serial, Bluetooth-to-Serial, Infrared-to-Serial or any other type of physically not present serial port. SuperCom locates these COMM ports even if non-standard names used (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 Multiserial 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 used in serial communications. 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. SuperCom for Windows can report event with the port name on serial port insertion/removal. Wireless Serial Adapter (RS-232, RS-422, RS-485) Are used to connect serial devices that are not linked by a physical cable connection. These can be Wireless USB-to-Serial adapters, Wireless Bluetooth to-Serial adapters, Wireless LAN-to-Serial adapter, etc. SuperCom for Windows can report event with the port name on serial port insertion/removal. 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 FIFO UART. SuperCom also runs serial data communication in low level buffered mode to avoid buffer overrun and to allow the applcation to perform other tasks as well. RS-485 Multidrop Besides supporting RS-232 and RS-422 serial communication, SuperCom also support the RS-485 data communication. RS-485 connects two or more stations on a two wire half-duplex bus system (network). That is bi-directional, half-duplex, multi-drop serial data communication over a single pair of cable. Each station can only transmit or receive data at a time (half-duplex). The so called "direction" is used to switch from transmit to receiving mode and vice versa. A timed switch of the "direction" is essential to avoid loss in data. SuperCom handles the RS-485 serial port transparently and offers a very low-latency switch of "direction" (more...). A four wire full-duplex connection may also be used. ::: Speed test performed on Desktop PC, AMD Athlon 64 X2 2.5GHz, Windows XP SP3 Speed tests documented in "SuperCom Technical Library - RS-485 and 9 Bit Multidrop Communications". Please request the PDF, if interested. The testing samples showed that SuperCom can switch several times within 1 ms. 9-Bit serial data 9-Bit serial communication (9-Bit framing) is mainly used to identify address byte within messages running on a RS-485 multidrop network but also on standard RS-232 connections. 9-Bit frames are usually not supported by the standard PC UART but simulated by the SuperCom software. Very fast response timing (low latency) by the software is essential to accomplish reliable 9-bit data communication. SuperCom does provide a very realiable solution here to be used with high level languages. Many Samples (e.g. C/C++, C#, Delphi) also included that demonstrate this operating mode. For example, transmitting a data packet using 9-bit addressing e.g.: TXPacket9BitCond(Com, cData, nDataCount, SEC0_1);

The 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 secured through buffered data communication with adjustable buffers for both directions. The application can safely perform other tasks while data transmission takes place.

SuperCom is fast, even in a multitasking operating system - it often solves issues where others are using system drivers.

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

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.

The Terminal emulations module offers ANSI, VT100, VT52, TTY.

Portable

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

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, plugging or unplugging serial PnP devices (serial comm port insertion/removal), TCP/IP network failures.

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

Type and amount of the events is also related to the used SuperCom software e.g. a SuperCom supporting only serial communications will not report TCP/IP network events.

       // optional event function
   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);

     // activate event reporting ...
   ComGetSetEventProc(Com, OnComm);

       ' optional event function
   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);

     // activate event reporting ...
   ComGetSetEventProc(Com, OnComm);

       // optional event function
   Function UserEventProc(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);

     // activate event reporting ...
   ComGetSetEventProc(Com, OnComm);

       // optional event function
   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);

     // activate event reporting ...
   SuperCom.ComGetSetEventProc(Com, OnComm);

Connecting

Establishing 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) and execute (on request) completely in background.

The SuperCom functions can trigger events during a connection attempt and provide the application with status information. So, even it executes in background the application stays in touch with the happening.

DLL API
In order to receive events the application has to provide an OnConnect* function. The OnConnect function is optional but very handy in many situations. Using OnConnect the application can receive progress information, information about the time left to complete a call or even cancel the connection attempt before it completes.

       // optional event function
   int OnConnect(Com, Action, TimeLeft, Data)
   {
      if (Action==acCONNECT_INFO)
      {
         // Received periodically, while in progress
      }
      if (Action==acCONNECT_OK)
      {
         // Connected !
      }
      if (Action==acCONNECT_FAILED)
      {
         // A connection attempt failed
      }
      if (Action==acCONNECT_USERBREAK)
      {
         // User interrupted
      }

      return infContinue;
   }

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

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

       ' optional event function
   Public Function OnConnect(Com, Action, TimeLeft, Data) As Long

      If Action = acCONNECT_INFO  Then
         'Received periodically, while in progress
      End If

      If Action = acCONNECT_OK  Then
         ' Connected !
      End If

      If Action = acCONNECT_FAILED Then
         ' A connection attempt failed
      End If

      If (Action=acCONNECT_USERBREAK) Then
         ' User interrupted
      End If

      OnConnect = infContinue

   End Function
        :
        :

     ' init  ...
   Call ComInit(Com)

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

       // optional event function
   Function OnConnect (Com, Action, TimeLeft, Data):Integer;
   Begin
      OnConnect:=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;
      If (Action = acCONNECT_USERBREAK) Then
      Begin
         // User interrupted
      End;
   End;

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

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

       // optional event function
   public int OnConnect(Com, Action, TimeLeft, 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:
              // User interrupted
              break;
      }
      return SuperCom.infCONTINUE;
   }

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

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

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 effective 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 (e.g. ZMODEM, YMODEM/BATCH, YMODEM, YMODEM-G, XMODEM-1K, XMODEM, XMODEM/CRC, KERMIT, Extended XMODEM and ASCII).

One of the most powerful among these protocols is ZMODEM that includes important features like "crash recovery", 32bit CRC, "batch file transfer", File Options, ZMODEM/8k block option and the powerful ADONTEC extension ZMODEM/32k (ZMODEM/64k shipped on request). The SuperCom ZMODEM implementation also includes support for slow communication channels and high latency connections (e.g. Satellite lines).

The KERMIT protocol and the Extended XMODEM are also offering a lot of interesting options.

Autodownload
is a file transfer protocol feature that enables the automated receive of a file transmitted from a remote host machine. Autodownloading is actually supported with the ZMODEM, KERMIT and Extended XMODEM protocol.

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 *. The OnFile function 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 OnFile will provide such information.

       // optional event function
   int COMMAPI OnFile(Com, Action, DataCount, FileData)
   {
      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, , OnFile);

       ' optional event function
   Public Function OnFile(Com, Action, DataCount, FileData) As Long

      If Action = acSYN  Then
         'Synchronization
      End If

      If Action = acRXING  Then
         ' A block of data received
      End If

      If Action = acTXING Then
         ' A block of data transmitted
      End If

      If Action = acTXFIN Then
         ' File successfully transmitted
      End If
        :
      OnFile = infContinue

   End Function
        :
        :

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

       // optional event function
   Function OnFile (Com, Action, DataCount, FileData):Integer;
   Begin
      OnFile:=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, , @OnFile);

       // optional event function
   public int OnFile(Com, Action, DataCount, FileData)
   {
      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,,,cbOnFileInfoFunc);

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 OnFile*. In order to receive events the application must provide an OnFile*. The OnFile is optional but enables to receive status information, if required and a better control over the happening (e.g. break a file transfer untimely).

With the SuperCom library each protocol can run on any established connection concurrently and in background. Queues of files to transfer are also possible to create and monitor (file-server etc.).

Industrial Protocols

Additional modules supporting the industry protocols 3964, 3964R, RK512, AS511, LSV2, Heidenhain LSV2 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 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

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.

Common Features List  (valid for Serial, TCP/IP and ISDN) Portable functions and API Easy to use and versatile API, not bound to one specific compiler only Fully buffered data transmission and background operation Simultaneously control up to 255 concurrent connections Support for asynchronous RS-232, RS-422, RS-485, Modem, TAPI, ISDN and TCP/IP is available (see also Software and Features) Standard Protocols: ZMODEM, YMODEM, YMODEM/BATCH, YMODEM-G, XMODEM, XMODEM/CRC, XMODEM-1K, KERMIT, , Extended XMODEM, ASCII Industrial Protocols like 3964/3964R, RK512, AS511, LSV/2, Heidenhain LSV/2 and TCP and MODBUS are available (see also Software and Features) Terminal emulation: ANSI, VT100, VT52, TTY User Event Functions: More than 35 different communications events report when: data received, transmit buffer gets empty, special data received, complete data packets received, connecting progress, status of file transmission and progress, plugging or unplugging of PnP serial devices, TCP/IP network failures, ... Send and receive binary data Send and receive Unicode strings (Windows) Multitasking support Supporting concurrent connections, file transfers, data transfer (multi threading) New and exceptional features in SuperCom 7 for Windows* SuperCom provides intelligent functions that considerably speed-up the development process in order to deliver fast a reliable solutions. More... DataPacket - Receive complete data packets based on some definitions. More... Trigger - Trigger events when custom data packets or strings received. More... DataFilter - Low level data filtering functions e.g. activate ready made data filter or inspect and change data while received or transmited. Also supported custom filter functions. More... Data Monitoring - Low level data monitoring functions - Integrated Debugging Library. Event Reporting - Thread-safe event reporting and synchronization with Windows controls or runtime library. Threaded File Queue - File transmission using Queue, working in background, reporting progress status, no need to develop threads! Connecting in background - This function is working in background, reporting progress status, no need to develop threads! In the meantime the application can do other things. Extended XMODEM protocol. XMODEM compatible incl. ZMODEM like features and more. The Extended XMODEM protocol offers buffers up to 64K for high speed file transfers, File Options (transmit file names, request a file from the sender, compare date, size etc.). ZMODEM File Options - Instructions for the file receiver. ZMODEM/8k block option and the powerful ADONTEC extension ZMODEM/32k (ZMODEM/64k shipped on request). More... KERMIT Protocol Integrated TAPI (Windows Telephony API) support. Dynamic priority for the data communication (very low to ultra high) Sharing Connections (e.g. TCP/IP or Serial) with a third party library is usually possible. ... and many other functions and protocol extensions. * Windows (32 and 64Bit) High performance data communication library SuperCom++ included (C++ class, Delphi, Pascal Objects) Many sample programs More than 200 functions Flexible and Cooperative (see sample) Many real world sample programs included with source code to customize or use as is. Detailed documentation incl. description of the hardware registers of V24 and/or RS232C. Many functions are documented including a short sample enabling a quick start and easy integration of SuperCom. No Royalties (License Information) Distribute with ease Simply install the SuperCom runtime files into the applications directory. Regular updates ensure compatibility with upcoming Windows versions FREE technical support Especially for RS-232, RS-422, RS-485 Up to 255 serial ports opened simultaneously (e.g. COM1 to COM255) and/or up to 255 connections simultaneously FIFO Chip Support (e.g. UART 16550/16650/16750/16950) Powerful flow control with RTS/CTS, DTR/DSR, XON/XOFF and user defined Control lines DTR, RTS Any baud rates supported by the hardware e.g. up to 921600 Baud (921,6 Kbps) SuperCom accepts any baudrate supported by your hardware. The Windows dialog 'control panel/hardware' may not always provide accurate information on this. Please consult the hardware manual. Often used standard PC bit-rates e.g. 5, 50, 110, 150, 300, 600, 1200, 4800, 7200, 9600, 12800, 14400, 19200, 23040, 38400, 57600, 115200 bps and through add-on serial cards 230400, 460800 and 921600 bps. Other serial hardware may support additional bit rates. Interrupt sharing Supports Multiport cards Supports Multiport Intelligent cards List installed serial ports, availability status, name and type User Event Functions: More than 35 different communications events report when: line signals or modem signals change, data received, transmit buffer empty, special data received, complete data packets received, connecting progress, file transmission status and progress. Dial-up connections using Modem (Hayes compatible) Dial-up connections using TAPI (Windows Telephony API) Direct access to a TAPI Modem or the serial interface it's attached to enables additional powerful features. Sending custom initialization commands to the TAPI Modem or connecting via the SuperCom direct modem API is possible and naturally many other custom solutions. Direct access to a TAPI Modem also offered . Dial-up connections using USB Modem Establish connections using GSM / GPRS Modem. More... Modem Sharing: Sharing a modem connection with other applications is usually possible. SuperCom can use Virtual Serial Ports e.g. COMM ports routed to an Ethernet PortServer, COMM Server, Terminal Server or Serial Server. Support for Wireless serial ports. Support for Bluetooth to serial ports. Support for Infrared to serial ports. Using serial ports redirected through the Windows Remote Desktop Protocol (RDP) Serial ports located on a remote computer. Supports USB to RS-232 / RS-485 adapters / converters that apear in Windows control panel as serial devices PnP Serial Port devices. SuperCom reports an event whenever a PnP serial port is attached or removed. Sharing Serial Ports with a third party library is usually possible. Especially for TCP/IP Especially for ISDN Especially for DOS/32, OS/2

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

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

Bonus Software Serial to TCP/IP GateWay sample applications (PortServer, COMM Server, Terminal Server or Serial Server) were developed with the SuperCom Suite and therein included with source code (for example C#, Visual Basic 6).

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 - Price List

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