SuperCom - 3964/R Protocol Engine

---

for Windows and Linux

Data Communication Solutions by ADONTEC Some SuperCom 3964 / RK512 Functions SuperCom AS511 Functions SuperCom MODBUS Functions 32 Bit and 64 Bit Versions available!

Version 10 Price List Product Range Call Me Back Translate

The serial protocol engine

The SuperCom Protocol Engine is the most complete programmers library supporting access to PLC data, industrial printer, automated storage systems, order fulfilment, ...

The SuperCom Protocol Engine supports many industrial data communication protocols (i.e. 3964, 3964R, DK3964R, DUST 3964(R), RK512, AS511 and MODBUS) to accomplish fast and stable data communication in automation and control.

The Protocol Modules

In order to communicate i.e. with a SIEMENS PLC, certain circumstances need to be observed before the PLC can accept your data (e.g. timeouts, number of repeats, packet size, checksum, resolution of sender conflicts,..).

The SuperCom 3964 and RK512 protocol modules can act as Master or Slave (with high or low priority) and transmit or receive data packets. Error recovery, automated retries and many protocol settings provide for a reliable data communication.

Drive up to 255 PLC concurrently. The serial hardware sets the limit.

Included API
The SuperCom Protocol Engine offers many API which one can use as needed by the application or compiler, separately or combined (e.g. functions in DLL and/or the ActiveX control, see also DUAL API).

Functions-Library (DLL API)
The SuperCom 3964 / RK512 protocol module includes many low level and high level functions.

A group of low level functions allow direct access to low level data packets (3964, 3964R, RK512). Enabling receiving and transmitting of data packets directly to the SPS.

Another group of high level functions allow direct access to Data Modules, Timer values, Counter values, Inputs, Outputs, Flags, etc... with ease and without the need to create and send low level telegrams in order to to get or set values.

File transfer functions based on the 3964/R protocol also included. They said «you can't do file transfer with this protocol». Well check the box.

ActiveX Control
Another API that can be used alone or in combination is the ActiveX control. The ActiveX process works transparently from the application in background. The transmission of data packets is completely buffered. The application does not has to block on a data packet. The ActiveX scans the receive direction, synchronizes with the remote station and stores received data packets in a FIFO buffer (First In First Out). In addition the engine fires events to synchronize the application. Data packets to transmit are stored in a FIFO buffer and transmitted whenever the remote station is ready.

The ActiveX component reports events to the application in order to signal conditions (see part below).

The ActiveX can store up to 32000 data packages in each direction. Applications have a lot of time to retrieve the received data packets !

The ActiveX provides many 3964 protocol specific properties and Events.

Flexible
The SuperCom 3964 protocol can also be used to communicate with other devices that offer a 3964 interface like printers, display, ... Based on the machine the content varies a lot and the programmer needs here to build machine specific data packets that can be transmitted using the SuperCom 3964 functions. The SuperCom 3964 function is working - in this particular case - like the postman. It does not care about the content it just transfers or receives the data packet transparently according to the 3964 / 3964R specification. More..

Data communication with MOBY ASM, SIM 41, SLG also supported.

Informative
The SuperCom 3964(R) protocol module is also capable to report Events, if it has been enabled by the caller. The events reported are describing the state of the protocol-stack. Events like EV_SYN_OK, EV_SYN_RETRY, EV_NAK report the current protocol state to the application and even allow untimely break of the protocol function. More..

It's also very easy to trace the protocol and watch the state of the protocol-stack.

An Alive Check is officialy not offered by the protocol specification but our samples show how easily it is to make it and check if the PLC is connected and ready.

Accomplish with ease
In most cases only a handful functions are needed i.e. to talk to a PLC. Your project is updated real fast. A lot of functions is backing you up to accomplish different tasks or configurations. Samples for well known development environments are also included to help you start real fast.

All functions were developed and testet according to the 3964, 3964R and RK512 protocol specification.

int ErrorCode;
TCOMMID Com = COM_2;

   ComInit (Com);
   ComSetState (Com, 9600, ...);

   if (RS_TX3964R (Com,
                   cData,  // any possible data
                   wCount, // amount of data bytes
                   &ErrorCode,
                   TRUE,
                   TRUE,
                   TRUE /* Master/Slave */))
   {
      printf ("Sent successfully.\n");
   }
   else
   {
      printf ("Error sending: %d\n", ErrorCode);
   }

   ComReset (Com);

char acBuffer [2000];
WORD RXCount;
int ErrorCode;
BOOLEAN fLast;
TCOMMID Com = COM_3;

   ComInit (Com);
   ComSetState (Com, 9600, ...);

   if (RS_RX3964R (Com,
                   acBuffer,
                   &RXCount,
                   &ErrorCode,
                   SEC_1,
                   &fLast,
                   TRUE))
   {
      printf ("Received: '%*s' (%s)\n",RXCount, acBuffer,
              fLast ? "last data packet":"more data follows");
   }
   else
      printf ("Error receiving: %d\n", ErrorCode);

   ComReset (Com);

Save time!  Functions accessing directly PLC data e.g. Data Modules, Timer values, Counter values, Marker / Flags bytes, inputs, outputs etc., ease the communication with a PLC (see example below).

   ComInit (Com);
   ComSetState (Com, 9600, ...);

     // write some words into a data module
   Res = RS_DataModuleWrite(Com,
                            10,      // Data Module number
                            4,       // DW offset
                            Buffer,  // buffer
                            XCount); // amount bytes

     // read some words out of a data module
   Res = RS_DataModuleRead(Com,
                           10,      // Data Module number
                           4,       // DW offset
                           XCount,  // amount bytes
                           Buffer)  // buffer

   ComReset (Com);

"non-blocking" function calls
Normal functions usually execute in „blocking“ mode. A function usually returns after it's completed. A function that is able to execute in „non-blockingg“ mode will be executed in background without blocking the calling process. When the function completes it reports the result code and any data by event.

The 3464/R and/or RK512 Protocol Module supports „blocking“ and „non-blocking“ function calls. In both modes same function name and parameters used. The advantage: The protocol functions work completely independently and transparently for the application in the background. The application calls the specific function and receives the result or any data by a SuperCom event.

Capture, Store, Forward
Communication at lower data packet level is possible thus allowing to capture, store and forward of 3964 data packets. Monitoring 3964 data packets or building a protocol converter is possible.

The SuperCom Protocol Engine can also be used to analyse and monitor error conditions on a PLC since polling of signals and values on short time frames is possible.

The software library needed is contained in the SuperCom Protocol Engine.

Box includes
An integrated DUAL API combination for serial (RS-232/422/485, 20mA, TAPI) consisting of:
 - SuperCom Serial for Windows (DLL API and ActiveX API)
 - Protocol Modules: 3964, 3964R, RK512, AS511, MODBUS
 - Other Protocols: ZMODEM, YMODEM, XMODEM, KERMIT, ASCII
 - Examples in background operation, Event driven samples, samples using "non-blocking" mode
 - Samples for C/C++, Visual C++, C++ Builder, Pascal, Delphi, Visual Basic, C#, Visual Basic .NET (VB Net), LabVIEW, FoxPro
More Details...

DOS Development is also supported by the SuperCom 3964R Engine. DOS libraries for the widely used compiler (BC, MSC, BP7) are included. Please confirm the DOS libraries you will need. For DOS Development SuperCom C/C++ for DOS or SuperCom Pascal for DOS is also needed.

License Information
Executable Applications (e.g. .EXE) developed using SuperCom 3964 Protocol Engine can be distributed royalty free.

Supported compilers
C++, C#, Delphi, Visual C++, Visual Basic, Visual Basic NET, C++ Builder, Borland C/C++, Microsoft C/C++, Borland Pascal, VBA, LabVIEW, FoxPro, PowerBuilder and other Windows programming tools (MS .NET ?).

The 3964/3964R Protocol Engine over TCP/IP and ISDN
The 3964/3964R Protocol Engine can now be used over TCP/IP and over ISDN connections. This is possible using the optional software SuperCom for TCP/IP, SuperCom for ISDN or the SuperCom Suite. To demonstrate the above, we also ship additional samples with the SuperCom Suite Industrial.

A flexibel and portabel library for use in Windows or Linux application*.

* Please select the specific Windows or Linux products codes.

Questions and Answers