Serielle Kommunikation Bibliothek und Komponente für rs-232, tcp/ip Kommunikation. Datenübertragung und Dateiübertragungs-Protokolle ZMODEM, YMODEM,XMODEM, KERMIT, MODBUS, 3964, RK512, LSV2. Unterstützt Entwicklung mit Visual Studio für NET, C#, VB Net, Klassen bibliothek, C++ Builder, Delphi, Visual Basic.

Datenübertragung und Dateiübertragungs-Protokolle ZMODEM, YMODEM,XMODEM, KERMIT, MODBUS, 3964, RK512, LSV2. Unterstützt Entwicklung mit Visual Studio für NET, C#, VB Net, Klassen bibliothek, C++ Builder, Delphi, Visual Basic. Serielle Kommunikation Bibliothek und Komponente für rs-232, tcp/ip Kommunikation.

Datenfilterung, Packetauswertung, Empfang von Datenpaketen und Telegrammen, ...

Data Filtering, Data Monitoring, Data Trigger, Data Packets, File Transmission Queue

SuperCom verfügt intelligente Funktionen um längere oder komplexe Operationen einfach zu lösen ohne dabei die Anwendung zu blockieren oder zu verzögern. Das Resultat sind stabile Anwendungen entwickelt wesentlich schneller als mit herkömmlichen Werkzeugen.

Dieses Konzept wird im folgenden mit Beispielen demonstriert. Wie bei SuperCom üblich, lassen sich alle folgende Bespiele über alle unterstützte Verbindungswege einsetzen (z.B. seriell, TCP/IP oder ISDN).

DLL API

  char cStart=STX; // Beginn Sequenz
  char cStop =ETX; // End Sequenz

     :

  if (DP_OK(RS_GetDataPacket(
                 szBuffer,
                 BufLen,       // Pufferlänge
                 cStart,       // beginnt mit
                 sizeof(cStart),
                 cStop,        // ended mit
                 sizeof(cStop),
                 0, // liefert alles was empfangen wurde
                 &TimeOut))
  {
     :
  }

     :

  cStart:Array[0..0] Of Char=(STX); // Beginn Sequenz
  cStop :Array[0..0] Of Char=(ETX); // End Sequenz

     :

  If (DP_OK(RS_GetDataPacket(
                 szBuffer,
                 BufLen,       // Pufferlänge
                 cStart,       // beginnt mit
                 SizeOf(cStart),
                 cStop,        // ended mit
                 SizeOf(cStop),
                 0, // liefert alles was empfangen wurde
                 @TimeOut)) Then
  Begin
     :
  End;

     :

  Dim cStart As Byte  ' Beginn Sequenz
  Dim cStop As Byte   ' End Sequenz

  cStart = STX
  cStop  = ETX

  If (DP_OK(RS_GetDataPacket(
                 szBuffer,
                 BufLen,       ' Pufferlänge
                 cStart,       ' beginnt mit
                 LenB(cStart),
                 cStop,        ' ended mit
                 LenB(cStop),
                 0, ' liefert alles was empfangen wurde
                 TimeOut)=True) Then

     :
   EndIf

     :

  char cStart=STX; // Beginn Sequenz
  char cStop =ETX; // End Sequenz

     :

  if (DP_OK(RS_GetDataPacket(
                 szBuffer,
                 BufLen,       // Pufferlänge
                 cStart,       // beginnt mit
                 Marshal.SizeOf(cStart),
                 cStop,        // ended mit
                 Marshal.SizeOf(cStop),
                 0, // liefert alles was empfangen wurde
                 TimeOut))
  {
     :
  }

     :

Die Parameter cStart, cStop definieren die Regeln für das Datenpaket. Danach wartet die Funktion bis ein Datenpaket entsprechend den Regeln empfangen wird, die gewünschte Anzahl an Daten empfangen wurde oder die eingestellte Zeit abläuft. Die Parameter cStart und cStop werden je nach Vorgaben definiert oder auch nicht.

WildCards
Nun ist nicht immer jedes Zeichen in einem Datenpaket bekannt (z.B. Prüfsummenzeichen, Längenbyte, etc.). Der Weg solche Stellen zu beschreiben geht über WildCards. Ein Wildcard ist ein spezielles Zeichen, in userem Fall zwei, die als Ersatz für ein unbekanntes Zeichen intepretiert werden. Die SuperCom Funktion nutzt die Zeichen "\?" als Wildcard. Da wird einfach für das betreffende unbekannte Zeichen ein Wildcard gesetzt. Eine Startsequenz könnte z.B. "H\?llo" definieren. Diese Sequenz belegt im Speicher 6 Bytes, die damit definierte Startsequenz ist jedoch nur 5 Bytes lang. Hier wurde der Wildcard an Position 2 gesetzt. Das bedeutet wir erwarten in Position 2 jedes beliebige Zeichen. Diese Startsequenz liefert bei "Hello", "Hallo", usw.

Diese Funktion ist so verlässlich, daß Kunden ganze Protokolle darüber abwickeln. Es kann hunderte Stunden der Fehlersuche in der Protokoll-Synchronisation einsparen. Einmal gesetzt arbeitet es zuverlässig und liefert die erwarteten Datenpakete.

Beispiel #2

     :
  char cBuffer[1024];
  DWORD dwDataCount=sizeof(cBuffer);
  TSYSTIME TimeOut=SEC_10;
     :

  sLineEnd = "\r\n"; // CRLF
  dwLen = (DWORD)strlen(pLineEnd);
  dwRes = RS_WaitString(Com,
                        cBuffer,      // Puffer
                        &dwDataCount, // Anzahl der erwarteten Zeichen
                        sLineEnd,
                        dwLen,
                        &TimeOut,
                        WSCF_BINARY);
     :

     :

  Var cBuffer:Array[1..1024] Of Char;
  dwDataCount:DWORD=Sizeof(cBuffer);
  TimeOut:TSYSTIME=SEC_10;
     :

  sLineEnd = PCHAR(#13#10);
  dwLen = StrLen(sLineEnd);
  dwRes = RS_WaitString(Com,
                        cBuffer,      // Puffer
                        dwDataCount,  // Anzahl der erwarteten Zeichen
                        sLineEnd,
                        dwLen,
                        @TimeOut,
                        WSCF_BINARY);
     :

     :

  cBuffer = Spaces(1024)
  dwDataCount=1024
  TimeOut=SEC_10
     :
  sLineEnd = vbCRLF;
  dwLen = Len(sLineEnd);
  dwRes = RS_WaitString(Com,
                        cBuffer,      ' Puffer
                        dwDataCount,  ' Anzahl der erwarteten Zeichen
                        sLineEnd,
                        dwLen,
                        TimeOut,
                        WSCF_BINARY);
     :

     :

  byte[]   sLineEnd;
  byte[]   cBuffer     = new byte[1024];
  DWORD    dwDataCount = 1024
  TSYSTIME TimeOut     = SEC_10
  DWORD    dwLen = StringToBuffer("\r\n", sLineEnd); // custom function

  dwRes = SuperCom.RS_WaitString(Com,
                        cBuffer,      // Puffer
                        dwDataCount,  // Anzahl der erwarteten Zeichen
                        sLineEnd,
                        dwLen,
                        TimeOut,
                        WSCF_BINARY);
     :

Ähnlich einfach geht es über das ActiveX API.

     GetBinary(&v, "a\\?\r\n", 4); // custom function
     m_SCom.SetDPStart(v);

     GetBinary(&v, "\r\n", 2); // custom function
     m_SCom.SetDPStop(v);

     m_SCom.SetDPTimeout(5*SEC_1);
     m_SCom.SetDPLimitLen(50);

     m_SCom.SetDPCollect(true);

     SCom1.DPStart := 'a\?'#13#10;
     SCom1.DPStop := #13#10;

     SCom1.DPTimeout := 5 * SEC_1;
     SCom1.DPLimitLen := 10;

     SCom1.DPCollect := 1;

     SCom1.DPStart = "a\?" & vbCr & vbLf
     SCom1.DPStop = vbCr & vbLf

     SCom1.DPTimeout = 3 * SEC_1
     SCom1.DPLimitLen = 10

     SCom1.DPCollect = True

     SCom1.DPStart = "a\\?\r\n";
     SCom1.DPStop = "\r\n";

     SCom1.DPTimeout = 3 * SEC_1;
     SCom1.DPLimitLen = 10;

     SCom1.DPCollect = true;

Die Eigenschaften DPStart, DPEnd, DPLimitLen und DPTimeout definieren die Regeln für das Datenpaket und DPCollect aktiviert den Datenpaketsammler. Von nun an werden fortlaufend Datenpakete entsprechend den Regeln gesammelt und gemeldet. Für die Signalisierung wird die Ereignisfunktion OnDataPacket verwendet, welche auch die Datenpakete gleich mitliefert.

Die Eigenschaften DPStart, DPEnd können unabhängig voneinander und je nach Vorgaben definiert werden oder auch nicht (z.B. Start="a?"CRLF, Ende=CRLF, '?'= ein beliebiges Zeichen).

WildCards
Der Puffer für den DPStart im obigen Beispiel belegt im Speicher 5 Bytes, die damit definierte Startsequenz ist jedoch nur 4 Bytes lang. Hier wurde der Wildcard an Position 2 gesetzt. Das bedeutet wir erwarten in Position 2 jedes beliebige Zeichen. Diese Startsequenz liefert bei "at"CRLF, "aT"CRLF, "ax"CRLF, usw.

Der Datenpaketsammler wird komplett im Hintergrund ausgeführt. Dadurch kann die Anwendung andere Aufgaben nachgehen bis die entsprechende Ereignisse eintreffen und die Daten liefern. Eine automatische Paket Sammelmaschine einfach aktiviert!

Trigger (Auslöser Datenpaket)
In vielen Situationen sollte es das Kommunikationsmodul sein, daß schnell und direkt auf empfangene Daten reagiert. Die Anwendung kann sich anderen Aufgaben widmen bis die Kommunikationsdaten die Aufmerksamkeit verlangen.

Wie im folgenden Beispiel gezeigt wird, ist es einfach mit SuperCom auf bestimmte Daten (Trigger) per Ereignis (Event) zu reagieren:

DLL API

     :
  pTrigger = "Username:|Password";
  dwLen = (DWORD)strlen(pTrigger);

  dwRes = RS_WaitString(Com,
                        NULL, // ignoriert
                        NULL, // ignoriert
                        pTrigger,
                        dwLen,
                        NULL, // ignoriert
                        WSCF_TRIGGER_ADD);
     :
    // oder dasselbe über das Trigger Helper API
  TriggerAdd(Com, pTrigger, dwLen);

     :
  pTrigger = PCHAR('Username:|Password');
  dwLen = StrLen(pTrigger);

  dwRes = RS_WaitString(Com,
                        NIL, // ignoriert
                        NIL, // ignoriert
                        pTrigger,
                        dwLen,
                        NIL, // ignoriert
                        WSCF_TRIGGER_ADD);
     :
    // oder dasselbe über das Trigger Helper API
  TriggerAdd(Com, pTrigger, dwLen);

     :
  sTrigger = "Username:|Password";
  dwLen = Len(sTrigger);

  dwRes = RS_WaitString(Com,
                        0, ' ignoriert
                        0, ' ignoriert
                        sTrigger,
                        dwLen,
                        0, ' ignoriert
                        WSCF_TRIGGER_ADD);
     :
    // oder dasselbe über das Trigger Helper API
  TriggerAdd(Com, Trigger, dwLen);

     :
  byte[] Trigger;
  dwLen = StringToBuffer("Username:|Password", Trigger); // custom function

  dwRes = SuperCom.RS_WaitString(Com,
                        null, // ignoriert
                        null, // ignoriert
                        Trigger,
                        dwLen,
                        null, // ignoriert
                        WSCF_TRIGGER_ADD);
     :
    // oder dasselbe über das Trigger Helper API
  TriggerAdd(Com, Trigger, dwLen);

Ein Trigger ist also ein Datenpaket bzw. eine Zeichenkette.

WildCards
Nun ist nicht immer jedes Zeichen bekannt (z.B. Prüfsummenzeichen, Längenbyte, etc.). Da wird einfach für das betreffende Zeichen ein Wildcard gesetzt. Ein Wildcard ist ein spezielles Zeichen, in userem Fall zwei, die als Ersatz intepretiert werden. Die SuperCom Funktion nutzt die Zeichen "\?" als Wildcard. Der Puffer für den Trigger "H\?llo" belegt im Speicher 6 Bytes, der Trigger hat jedoch die Länge 5. Hier wurde der Wildcard an Position 2 gesetzt. Das bedeutet wir erwarten in Position 2 jedes beliebige Zeichen. Dieser Trigger meldet z.B. bei "Hello", "Hallo" usw. Ein zusätzliches kleines Handbuch behandelt dieses mächtige Trigger Helper API und zeigt auch Aspekte der Anwendungen von Trigger in Protokollen.

SuperCom behandelt den Trigger intern nur im binären Modus. Dadurch werden nicht nur Zeichenketten sondern auch binäre Daten korrekt verarbeitet.

Diese Arbeitsweise entlastet die Anwendung sehr, da nicht ständig nach den empfangenen Daten geprüft werden muß. Sobald eine definierte Zeichenkette von SuperCom empfangen wird, signalisiert es die Anwendung per Ereignis (Event). Das Trigger-Ereignis EV_TRIGGER wird über die UserEventProc gemeldet.

Ähnlich einfach geht es über das ActiveX API .

     :
   v = "Username:|Password:";
   m_SCom.SetTrigger(v);
   m_SCom.SetTriggerAction(SCOMM_TRIGGER_ADD);
     :

     :
   SCom.Trigger:='Username:|Password:';
   SCom.TriggerAction:=SCOMM_TRIGGER_ADD;
     :

     :
   SCom.Trigger="Username:|Password:"
   SCom.TriggerAction=SCOMM_TRIGGER_ADD
     :

     :
   SCom.Trigger="Username:|Password:";
   SCom.TriggerAction=SCOMM_TRIGGER_ADD;
     :

Sobald eine definierte Zeichenkette (Trigger) empfangen wird meldet SuperCom das spezielle Ereignis SCOMM_EV_TRIGGER über die OnComm Event Funktion. Es können beliebige Zeichenketten (Trigger) für die Überwachung gesetzt werden und genauso einfach wieder entfernt werden.

WildCards
Für nicht bekannte Zeichen kann das Wildcard "\?" gesetzt werden z.B "H\?llo".

Daten-Filter
Bestimmte Aufgaben erfordern die Filterung (Austausch oder entfernung von bestimmten Daten) des Datenstroms. Es ist aus vielen Gründen vorteilhaft, wenn diese Aufgabe im Kommunikationsmodul schnell und direkt bewältigt wird ohne Eingriff der Anwendung.

SuperCom bietet eine Daten-Filter Funktionalität für die Datenfilterung und -manipulation innerhalb der Datenkommunikation.

DLL API

Die Funktion ComFilterInit installiert die SuperCom Datenfilterung entsprechend den vordefinierten Regeln. Die gesamte Datenfilterung findet auf unterster Ebene während des Datenempfangs bzw. -versands statt. Dabei gibt es mehrere vordefinierte Regeln, welche über ComFilterInit eingestellt werden können. Die Anwendung erhält stets die netto Daten.

ActiveX API

     m_SCom.DataFilter(FLAG_DATA_FILTER_RX_STRIP_NULL);

     SCom1.DataFilter:=FLAG_DATA_FILTER_RX_STRIP_NULL;

     SCom1.DataFilter=FLAG_DATA_FILTER_RX_STRIP_NULL

     SCom1.DataFilter=FLAG_DATA_FILTER_RX_STRIP_NULL;

Die Eigenschaft DataFilter definieren die Regeln für die Datenfilterung.

Zusammenfassend
Die hier vorgestellten Werkzeuge bieten verschiedene Wege zur Problemlösung. Viele weitere Kombinationen sind ebenfalls möglich. Das Handbuch bietet hierzu reichlich information und bei gezielten Anfragen zeigen unsere techniker gerne weitere Lösungsmöglichkeiten auf.

Intelligente Funktionen lösen komplizierte Aufgaben. Das was man von einem professionellen Tool erwartet.

Eine DUAL API SuperCom software ermöglicht eine noch bessere Anwendung der hier vorgestellten Werkzeugen. Es erlaubt, unter anderem, den Aufruf von Funktionen aus dem ActiveX API und DLL API je nach Bedarf.

Vielseitigkeit
SuperCom ist weiterhin das einzige Toolkit, daß die unterschiedlichsten Entwicklungsumgebungen unterstützt. Es ist nicht, wie üblich, an eine Entwicklungsumgebung festgebunden. Der Entwickler hat die Freiheit seine Entwicklungsumgebung bzw. den Compiler nach seinem aktuellem Bedarf auszuwählen. Das bedeutet eine enorme Zeit- und Kostenersparnis für die Entwicklungsabteilung.