Serielle Kommunikation mit Protokoll 3964, RK512, AS511

Industrie Protokolle 3964, RK512, AS511 für die serielle Kommunikation

SuperCom - 3964/R Protocol Engine

Die 3964/3964R Protocol Engine

Die SuperCom 3964/3964R Protocol Engine ist eine Entwickler Bibliothek bestehend aus mehreren industriellen Datenkommunikations-Protokollen (3964, 3964R, RK512, AS511, MOBDUS) zur Steuerung von SPS.

Die SuperCom 3964/3964R Protocol Engine ist eine Kombination von einem ActiveX Prozess und ein prozedurales Interface in DLL's. Die beiden Komponenten sind einzeln und gemeinsam nutzbar (DUAL API).

Das Protokoll Modul

Für die Kommunikation mit einer speicherprogrammierbaren Steuerung von SIEMENS (SPS), müssen einige Voraussetzungen erfüllt werden bevor die SPS Daten annehmen kann (z.B. das Zeitverhalten, Wiederholungen, Paketgröße, Prüfsumme, Quittungen, Auflösung von Sendekonflikten). Diese Eigenschaften werden durch die 3964, 3964R und RK512 Protokoll Spezifikation geregelt.

Das SuperCom 3964/RK512 Protokoll Modul übernimmt alle notwendigen Einstellungen und die Protokolldetails. Ohne ein großes oder kompliziertes API lernen zu müssen kommunizieren Sie mit der SPS.

Das Protokoll unterstützt sowohl den Master- als auch den Slave-Modus und kann mit hoher oder niedriger Priorität senden bzw. empfangen. Automatische Fehlerbehebung und Wiederholungen in Verbindung mit den vielen Protokoll-Einstellungen sorgen für eine reibungslose Datenkommunikation. Bis zu 255 SPS gleichzeitig angesprochen werden. Die Schnittstellen-Hardware setzt die Grenze.

ActiveX API
Der Prozess im ActiveX arbeitet vollkommen transparent im Hintergrund. Der Telegrammverkehr erfolgt stets gepuffert. Für die Anwendung bedeutet es keine Wartezeit, keine Blockade. Die ActiveX überwacht die Empfangsrichtung, synchronisiert mit der Gegenstelle und speichert empfangene Telegramme in einem FIFO-Puffer (First In First Out). Zusätzlich wird die Applikation mittels Events informiert. Die zu übertragenen Datenpakete werden entgegengenommen, in einem FIFO-Puffer gespeichert und sobald die Gegenstelle bereit ist übertragen.

Das ActiveX informiert die Anwendung zusätzlich mittels Events z.B. sobald das Telegramm übertragen wurde (siehe auch weiter unten).

Das ActiveX kann bis zu 32000 Datenpakete für jede Richtung speichern. Die Applikation hat damit, auch bei hohem Datenverkehr, eine Menge Zeit, um die Pakete abzuholen !

Im ActiveX existieren mehrere 3964 protokollspezifische Eigenschaften und Ereignisse.

DLL API
Das SuperCom 3964/RK512 Protokoll Modul bietet für die Kommunikation mit der SPS mehrere Funktionen.

Parametergesteuert verhalten sich die Routinen als Master oder Slave (hochprior oder niederprior), senden bzw. empfangen Prüfsummen und warten eine vorgegebene Zeit auf den Start der Übertragung.

Eine Gruppe von Low-Level Funktionen ermöglichen den direkten Zugriff auf die Datenpakete (3964, RK512). Dadurch ist der direkter Versand bzw. Empfang von Telegrammen.

Eine weitere Gruppe von High-Level Funktionen ermöglichen den direkten Zugriff auf Datenbausteine, Eingangsbytes, Ausgangsbytes, Merkerbytes, Zeitzellen etc. einfach und ohne den Bedarf eigene Low-Level Telegramme zu versenden um Werte zu setzen oder auszulesen.

Auf 3964 bzw. 3964R basierende Dateiübertragungs - Funktionen runden die Funktionalität ab.

Flexibel und informativ
Das SuperCom 3964 Protokoll-Modul meldet, auf Wunsch, Ereignisse, die den Zustand des Protokoll-Stacks beschreiben. Ereignisse wie z.B. EV_SYN_OK, EV_SYN_RETRY, EV_NAK melden den aktuellen Protokoll Zustand an die Anwendung und ermöglichen sogar den vorzeitigen Abbruch.

Es ist auch sehr einfach das Protokoll und die Übergänge im Protokoll-Stack zu überwachen.

Ein Alive Check wird vom Protokoll offiziell nicht angeboten, die Beispiele zeigen wie man es trotzdem machen kann und auf einfachste Weise prüfen ob z.B. die SPS angeschlossen und bereit ist.

Schnell und einfach ans Ziel
Für die Datenkommunikation mit einer SPS sind, in der Regel, nur eine Handvoll Funktionen nötig. Dadurch ist das Projekt schnell angepasst. Durch den großen Vorrat an Funktionen können unterschieldiche Aufgaben und Konfigurationen leicht bewältigt werden. Beispiele für die gängigen Programmiersprachen bieten den optimalen Einstieg.

Beispiel (3964/R Low Level Protokoll API):

int ErrorCode;
BYTE Com = COM_2;

   ComInit (Com);
   ComSetState (Com, 9600, 8, 1, 'E', SIGNAL_NONE);

   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;
BYTE Com = COM_3;

   ComInit (Com);
   ComSetState (Com, 9600, 8, 1, 'E', SIGNAL_NONE);

   if (RS_RX3964R (Com,
                   acBuffer,
                   &RXCount,
                   &ErrorCode,
                   SEC_1,
                   &fLast,
                   TRUE /*BCC*/))
   {
       printf ("Received: '%*s' (%s)\n",RXCount, acBuffer,
                fLast ? "letztes Paket" : "weitere folgen");
   }
   else
       printf ("Error receiving: %d\n", ErrorCode);

   ComReset (Com);

Sparen Sie Zeit !  Funktionen für den direkten Zugriff auf Datenbausteine, Eingangsbytes, Ausgangsbytes, Merkerbytes, Zeitzellen etc. machen es möglich (siehe folgendes Beispiel).

Beispiel (High Level Protokoll API):

   ComInit (Com);
   ComSetState (Com, 9600, 8, 1, 'E', SIGNAL_NONE);

     // Datenwörter im Datenbaustein schreiben
   Res = RS_DataModuleWrite(Com,
                            10,      // Datenbaustein Nummer
                            4,       // DW Offset
                            Buffer,  // Puffer mit Daten
                            XCount); // Anzahl der Daten

     // Datenwörter aus Datenbaustein lesen
   Res = RS_DataModuleRead(Com,
                           10,      // Datenbaustein Nummer
                           4,       // DW Offset
                           XCount,  // Anzahl der Daten
                           Buffer)  // Puffer für die Daten

   ComReset (Com);

„nicht blokierende“ Funktionen
Normale Funktionen arbeiten in der Regel im „blockierenden“ Modus. Die Funktion kehrt erst wieder zum Aufrufer zurück, wenn alles erledigt ist. Eine Funktion im „nicht blokierenden“ Modus dagegen kehrt sofort zurück zum Aufrufer und wird im Anschluß im Hintergrund ausgeführt ohne dabei die Anwendung zu blokieren. Sofort nach Abschluß wird das Resultat per Ereignis gemeldet.

Im 3464/R bzw. RK512 Protokoll Modul (DLL API ) werden die selben Funktionen, nach Bedarf, im „blokierenden“ oder „nicht blokierenden“ Modus ausgeführt. Der Vorteil: Die Protokoll-Funktionen arbeiten komplett im Hintergrund ohne eigens Threads dafür zu programmieren und nur ein Set an Funktionen.

Wie beim SuperCom üblich wird das "einfrieren" der Anwendung verhindert und die Arbeit übernimmt komplett und transparent die SuperCom Protokoll Software. Die Anwendung ruft die gewünschte Funktion auf und nimmt das Resultat bzw. die Daten per SuperCom Ereignis entgegen.

Die dafür notwendige Software ist in der SuperCom 3964/3964R Protocol Engine enthalten.

Lieferumfang
Eine integrierte DUAL API Kombination für RS-232/RS-422/RS-485 bestehend aus:
 - SuperCom RS-232 Software für Windows (DLL API und ActiveX API)
 - Protokoll Module: 3964, 3964R, RK512, AS511, MODBUS
 - Other Protocols: ZMODEM, YMODEM, XMODEM, KERMIT, ASCII
 - Threadgesteuerte Beispiele, Ereignisgesteurte Beispiele, Beispiele im "non-blocking" Modus
 - Beispiele für C/C++, Pascal, C++ Builder, Delphi, Visual C++, Visual Basic, C#, Visual Basic .NET (VB .NET)
    Mehr Details...

DOS Anwendungen werden von der SuperCom 3964 Protocol Engine auch unterstützt. Bibliotheken für die üblichen Compiler (z.B. BC, MSC, BP7) sind vorhanden. Bitte vorab klären ob Ihr Compiler unterstützt wird. Die Software SuperCom C/C++ für DOS bzw. SuperCom Pascal für DOS wird für die Entwicklung von DOS Anwendungen ebenfalls benötigt.

Lizenzbedingung
Ausführbare Anwendungen (.EXE) können frei weitergegeben werden.

Unterstützte Compiler
Visual C++, Visual Basic, C#, Visual Basic .NET (VB .NET), Delphi, C++ Builder, Borland C/C++, C++ Builder, Microsoft C/C++, Borland Pascal, VBA, LabView, PowerBuilder und andere Windows Sprachen (.NET Framework ?).

Die 3964/3964R Protocol Engine über TCP/IP und ISDN
Die 3964/3964R Protocol Engine kann auch über TCP/IP oder ISDN eingesetzt werden. Möglich machen es die Optionen SuperCom für TCP/IP, SuperCom für ISDN oder die SuperCom Suite. Entsprechende Beispiele sind im Paket SuperCom Suite Industrial enthalten.