Serial Communication Library using protocol 3964, RK512, AS511 for automation

Industrial Protocols 3964, RK512, AS511 for serial Communication library

SuperCom - 3964/R Protocol Engine

The serial protocol engine

The SuperCom Protocol Engine is the most complete programmers library supporting data communication using industrial protocols (3964, 3964R, RK512, AS511 and MODBUS) for use in automation and control.

The SuperCom Protocol Engine is a combination of an ActiveX process and functions within DLL's. Both components can be used separately or together (DUAL API).

The Protocol Modules

In order to communicate 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.

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.

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, 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.

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 to talk to the 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,
                   wCount,
                   &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 your time !  Functions to handle directly with Data Modules, Timer values, Counter values, Marker / Flags bytes, inputs, outputs etc., make that possible (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-blocking“ 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 (DLL API ) supports „blocking“ and „non-blocking“ function calls. In both same function name and parameters used. The advantage: The functions executing completely in background without the need to develop custom threads and only one set of functions to know. 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, 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
 - Threaded samples, 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
Executables 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 ?).

Now 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.

Questions and Answers.