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.

SuperCom's Smart Path

---

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

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

SuperCom verfügt über intelligente Funktionen um längere oder komplexe Operationen einfach zu lösen (Smart Path).

Diese intelligente Funktionen erleichtern nicht nur die Lösung von komplexen Aufgaben schnell sondern arbeiten im 'nicht-blockierenden' Modus, im Hintergrund. Das Resultat ist eine sehr stabile Anwendungen die schnell, weich und ruckelfrei arbeitet und wesentlich schneller entwickelt 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, 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)) 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))
  {
     :
  }

     :

Zusätzlich kann RS_GetDataPacketEx obiges vollständig im Hintergrund ausführen und die gesammelten Daten per Ereignisse (OnDataPacket) liefern.

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.

Der Parameter für Start und Stopp kann ein einzelnes Datenbyte (Zeichen) oder eine Folge von Datenbytes auch binäre Daten sein und sogar Platzhalter (Wildcards) enthalten.

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 (Platzhalter) ist ein spezielles Zeichen, in userem Fall zwei, die als Ersatz für ein unbekanntes Zeichen intepretiert werden. Die SuperCom Funktion nutzt die Zeichen "\?" für den "Ein-Zeichen Wildcard". 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.

Wertebereiche
In manchen Fällen sind die zu erwartenden Bytes eines Triggers bekannt bestehen jedoch aus einen Satz von Werten (set) oder aus einem Bereich von Werten (range). Diese Konstellation kann mit der Sequenz \[] beschrieben werden. Einzelne Werte werden, innerhalb der eckigen Klammern, durch ein ',' getrennt aufgelistet und Bereiche mit Anfang- und Endwert getrennt durch '..'.

Die Kombination von Wildcards und Wertebereiche ermöglicht komplexe Datenpakete zu filtern.

Die Datenpacket-Sammler Funktion ist so verlässlich, daß sogar ganze Protokolle darüber abgewickelt werden können. Einmal richtig konfiguriert arbeitet es zuverlässig und liefert die erwarteten Datenpakete, bei Bedarf auch per Event und Hintergrundbetrieb (RS_GetDataPacketEx).

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

Info:
Um RS_WaitString herum wurden die speziellen Funktionen wie RS_GetDataPacket, RS_GetDataPacketEx, TriggerAdd, TriggerDel, TriggerSignaled, ... entwickelt. Alternativen um jedes mögliche Problem flexibel und mit excellenter Ausführgeschwindigkeit zu lösen.

Ähnlich einfach geht es über das ActiveX API und auch bei Klassen Bibliotheken:

     GetBinary(&v, "at\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.SetDPStart('at'#13#10);
     SCom1.SetDPStop(#13#10);

     SCom1.SetDPTimeout(5 * SEC_1);
     SCom1.SetDPLimitLen(10);

     SCom1.SetDPCollect(TRUE);

     SCom1.DPStart = "at" & vbCr & vbLf
     SCom1.DPStop = vbCr & vbLf

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

     SCom1.DPCollect = True

     SCom1.DPStart = "at\r\n";
     SCom1.DPStop = "\r\n";

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

     SCom1.DPCollect = true;

     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.SetDPStart := 'a\?'#13#10;
     SCom1.SetDPStop := #13#10;

     SCom1.SetDPTimeout := 5 * SEC_1;
     SCom1.SetDPLimitLen := 10;

     SCom1.SetDPCollect := 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;

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.

Zusätzlich zu den Wildcards können auch Wertebereiche definiert werden und somit komplexe Datenpakete gesammelt werden.

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

  TriggerAdd(Com, pTrigger, dwLen);

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

  TriggerAdd(Com, pTrigger, dwLen);

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

  TriggerAdd(Com, sTrigger, dwLen);

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

  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.

Zusätzlich zu den Wildcards können auch Wertebereiche definiert werden und somit komplexe Trigger verarbeitet werden.

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

Zusätzlich zu den Wildcards können auch Wertebereiche definiert werden und somit komplexe Trigger verarbeitet werden.

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

     ComFilterInit(..., FLAG_DATA_FILTER_RX_STRIP_NULL |
                        FLAG_DATA_FILTER_TX_STRIP_NULL);
     :

     ComFilterInit(..., FLAG_DATA_FILTER_RX_STRIP_NULL OR
                        FLAG_DATA_FILTER_TX_STRIP_NULL);
     :

     Call ComFilterInit(..., FLAG_DATA_FILTER_RX_STRIP_NULL OR _
                             FLAG_DATA_FILTER_TX_STRIP_NULL);
     :

     SuperCom.ComFilterInit(..., FLAG_DATA_FILTER_RX_STRIP_NULL |
                                 FLAG_DATA_FILTER_TX_STRIP_NULL);
     :

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.

Ereignisse werden bei Bedarf kontinuirlich gemeldet. Die Anwendung ist stets darüber informiert welche Datei gerade übertragen wird und den Fortschritt.

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.