✔ Protokoll selber aufbauen

D

D12

Mitglied
Guten Morgen Tutorials,

ich bin gezwungen mir ein Protokoll für eine Kommunikation über eine Netzwerkkarte selbst zusammen zu stellen.

Kann mir hier einer einen Beispielquellcode zeigen, wie ich Byte für Byte einen solchen Protokollheader aufbaue und sende?

Grüße
D12
 
Hi,

Performance ist nich das wichtigste, aber im Moment habe ich einen instabilen Code, der mit einer S5 kommuniziert. Ich habe einen Schleifentest, der nach 5 bis 12 Versuchen stehenbleibt und auf die S5 wartet, die dann nicht mehr antwortet, weil dot.net noch andere Pakete sendet, bzw. nicht die richtigen Parameter. Denn nach jeder erfolgreichen Kommunikation, muss ein zusätzliches Protokoll gesendet werden. Am besten wäre ich könnte direkt das H1 Protokoll und COTP nachbilden, dann kann ich mir den Protokollwandler sparen.

Das Ganze muss schnell gehen, bin grad aus der Umschulung, habe letzte Woche Prüfung bestanden und gleich beim neuen Arbeitgeber ein solches Problem,... :o( Das kann mich den neuen Job kosten...

Hier der Beispielcode:
Code: 
using System;
using System.Net;
using System.Net.Sockets;


namespace SimpleFetchRead
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			
			int ende = 15;
			for (int i = 1; i<=ende; i++)
			{
				Console.WriteLine("Schleifen-Durchlauf " + i + " von " + ende + "!");
				FetchRead();
				Console.WriteLine("--------- --------- --------- --------- --------- --------- --------- --------- ");
				Console.WriteLine();
			}
		}
		
		public static void FetchRead()
		{
			//*** S5 Header wird initialisiert
			Console.WriteLine("S5 Header wird initialisiert");
			char syskennA	= 'S';  	//*** Systemkennung
			char syskennB	= '5';		//*** Systemkennung
			int sysheader 	= 16;		//*** Headerlänge für Telegramm
			int opcodekenn	= 1;		//*** Kennung für OpCode
			int opcodelen	= 3;		//*** Länge des Opcode
			int opcode		= 5;		//*** eigentlicher OpCode, 3 = Anforderungs-Telegramm, 4 = Antwort-Telegramm
			int orgblck		= 3;		//*** Kennung des OrgBlock
			int orgblcklen	= 8;		//*** Länge des OrgBlock
			int orgblckkenn	= 1;		//*** Kennung des OrgBlock, nur DB
			int dbnr		= 110;		//*** Nummer Datenbaustein
			int dwadrhigh	= 0;		//*** Adresse erstes Datenwort (high)
			int dwadrlow	= 5;		//*** Adresse erstes Datenwort (low)
			int dwlenhigh	= 0;		//*** Datenwortlänge (high)
			int dwlenlow	= 1;		//*** Datenwortlänge (low)
			int lblockkenn	= 255;		//*** Leerblock Kennung
			int lblocklen	= 2;		//*** Leerblock Länge					
				
			//*** Sendestring wird zusammengestellt
			Console.WriteLine("Byte-Array für Anforderung wird zusammengestellt");
			Byte[] ba = new byte[16];
			ba[0] 	= 	Convert.ToByte(syskennA);
			ba[1] 	= 	Convert.ToByte(syskennB);
			ba[2] 	= 	Convert.ToByte(sysheader);
			ba[3] 	= 	Convert.ToByte(opcodekenn);
			ba[4] 	= 	Convert.ToByte(opcodelen);
			ba[5] 	= 	Convert.ToByte(opcode);
			ba[6] 	= 	Convert.ToByte(orgblck);
			ba[7] 	= 	Convert.ToByte(orgblcklen);
			ba[8] 	= 	Convert.ToByte(orgblckkenn);
			ba[9] 	= 	Convert.ToByte(dbnr);
			ba[10] 	= 	Convert.ToByte(dwadrhigh);
			ba[11] 	= 	Convert.ToByte(dwadrlow);
			ba[12] 	= 	Convert.ToByte(dwlenhigh);
			ba[13] 	= 	Convert.ToByte(dwlenlow);
			ba[14] 	= 	Convert.ToByte(lblockkenn);
			ba[15] 	= 	Convert.ToByte(lblocklen);
			
			
			//*** Anforderungstelegramm wird gesendet
			Console.WriteLine("Anforderungstelegramm wird gesendet");
			TcpClient client = new TcpClient();
			client.Connect("159.151.99.28", 5015);
			Console.WriteLine(client.LingerState.LingerTime.ToString());			
			
			NetworkStream stream = client.GetStream();			
			//Byte[] data = System.Text.Encoding.ASCII.GetBytes(sstr);
			Byte[] data = ba;
			stream.Write(data, 0, data.Length);
			Console.WriteLine("Anforderungstelegramm wurde gesendet");
			
			//*** Antwort-Telegramm wird ausgelesen
			Console.WriteLine("Anwendung wartet auf Antwort-Telegramm");
			int ByteLen = (dwlenhigh	* 255) + dwlenlow + 16;
			data = new Byte[ByteLen];
			String responseData = String.Empty;
			Int32 bytes = stream.Read(data, 0, ByteLen);			
			responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
			Console.WriteLine("Antwort-Telegramm wurde empfangen");
			Console.WriteLine("Antwort der S5: " + responseData.Substring(16));
			
			Console.WriteLine("Verbindung wird abgebaut!");
			stream.Flush();
			stream.Close();
			client.Close();
		}
	}
}

Vielleicht siehst Du einen Fehler, den ich nicht sehe. Manchmal sieht man den Wald vor lauter Bäumen nicht oder sitzt einfach nur auf den eigenen Gehirnwindungen.

Grüße
D12
 
Weitere Infos:

Ich muss entweder die Eigenschaften des TCP besser kontrollieren können, oder direkt die H1/COTP Protokolle an die S5 senden.

Én Detail:
1. COTP Protokoll an die S5
Code: 
0000  08 00 06 01 00 03 aa 00  04 00 3e 04 00 18 fe fe   ........ ..>.....
0010  03 00 13 60 09 1a 00 00  00 ca 00 01 8c 08 00 00   ...`.... ........
0020  00 ca 00 00 00 01 00 00  00 00 00 00 00 00 00 00   ........ ........
0030  00 00 00 00 00 00 00 00  00 00 00 00               ........ ....

2. H1 Protokoll an die S5
Code: 
0000  08 00 06 01 00 03 aa 00  04 00 3e 04 00 1c fe fe   ........ ..>.....
0010  03 00 07 f0 09 1a 80 00  00 ca 53 35 10 01 03 05   ........ ..S5....
0020  03 08 01 6e 00 05 00 01  ff 02 00 00 00 00 00 00   ...n.... ........
0030  00 00 00 00 00 00 00 00  00 00 00 00               ........ ....

3. nun reagiert die S5 mit einem COTP
Code: 
0000  aa 00 04 00 3e 04 08 00  06 01 00 03 00 0e fe fe   ....>... ........
0010  03 00 09 60 d1 04 00 00  00 cb 00 00 10 01 03 06   ...`.... ........
0020  0f 03 00 ff 07 05 00 01  ff 02 2f f2 53 20 01 0a   ........ ../.S ..
0030  c6 01 03 c4 01 01 c3 02  c2 a7 00 00               ........ ....

4. und dann direkt mit dem H1 was meine Daten enthält
Code: 
0000  aa 00 04 00 3e 04 08 00  06 01 00 03 00 1e fe fe   ....>... ........
0010  03 00 07 f0 d1 04 80 00  00 ca 53 35 10 01 03 06   ........ ..S5....
0020  0f 03 00 ff 07 05 00 01  ff 02 30 67 53 20 01 0a   ........ ..0gS ..
0030  c6 01 03 c4 01 01 c3 02  c2 a7 00 00               ........ ....

5. nun noch ein COTP an die S5 für den Verbindungsabbau
Code: 
0000  08 00 06 01 00 03 aa 00  04 00 3e 04 00 0e fe fe   ........ ..>.....
0010  03 00 09 60 09 1a 00 00  00 cb 00 00 00 00 00 00   ...`.... ........
0020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   ........ ........
0030  00 00 00 00 00 00 00 00  00 00 00 00               ........ ....

Wenn ich die nachbilden kann dann wäre ich glücklich und mein Job erst mal gesichert. Bin Berufsanfänger und noch in der Probezeit, direkt der erste Auftrag entwickelt sich zu einem Fiasko.

Wenn ich weiterhin mit dem Protokollwandler arbeite, dann kommt vor dem ersten Protokoll ein TCP an den Protokollwandler:
Code: 
0000  aa 00 04 00 3e 04 00 0d  56 d9 cb 64 08 00 45 00   ....>... V..d..E.
0010  00 38 2c f1 40 00 80 06  00 00 9f 97 63 1e 9f 97   .8,.@... ....c...
0020  63 1c 0f 2e 13 97 5d 42  1d 39 00 00 0e 44 50 18   c.....]B .9...DP.
0030  fa 74 05 94 00 00 53 35  10 01 03 05 03 08 01 6e   .t....S5 .......n
0040  00 05 00 01 ff 02                                  ......

und nach dem fünften ein weiteres vom Protokollwandler an den .NET Rechner
Code: 
0000  00 0d 56 d9 cb 64 aa 00  04 00 3e 04 08 00 45 00   ..V..d.. ..>...E.
0010  00 3a a1 14 00 00 fe 06  16 40 9f 97 63 1c 9f 97   .:...... .@..c...
0020  63 1e 13 97 0f 2e 00 00  0e 44 5d 42 1d 49 50 18   c....... .D]B.IP.
0030  06 1c 4b f2 00 00 53 35  10 01 03 06 0f 03 00 ff   ..K...S5 ........
0040  07 05 00 01 ff 02 30 67                            ......0g

Die Protokolle 1 bis fünf werden vom Protokollwandler erzeugt.

Wenn möglich, möchte ich die Protokolle (H1 & COTP) direkt erzeugen.

Oder das TCP besser kontrollieren können; denn da stimmen die Segment Nr, ACK, Nr's etc nicht. Mit scheint es nach einem längeren Vergleich mit dem Sniffer, bei einer Kommunikation eines OPC Server und meiner Anwendung, das die S5 keinen Verbindungsabbau bekommt und weiter sendet.

So kommt die S5 durcheinander und reagiert nach ein paar Minuten mit einem ziemlich arroganten Ignonieren meiner Anfragen, bis der Start/Stop Schalter umgelegt wird, worauf sie dann gleich wieder munter drauflos labert, bis ich nach ein paar Durchläufen wieder ignoriert werde. *frust*

Mir fehlt eigentlich nur ein beispiel-Code, wie ich ein Protokoll als ByteArray über die Netzwerkkarte rausgebe, bzw. die Karte abhöre wenn antworten kommen!

So, mal schauen ob hier einer was für mich hat.

LG D12
 
Naja, du verwechselst da glaub ich etwas. COTP baut nicht auf TCP auf, sondern ist quasi ein Konkurrent. Wenn du jetzt mit TcpClient und TcpListener arbeitest, setzt du am falschen Protocol auf.

Die Sockets dürften da die wesentlich bessere Wahl geben. Laut ProtocolFamily-Enumeration, wird das ISO-Protokol unterstützt .. COTP gehört ja zur netten ISO-Familie. Das heißt du müsstest das Protokol wirklich selbst implementieren und ins Framework klatschen.

Andere Frage: Unterstützt deine Zielapplikation das TPKT-Protokol? Dieses wäre etwas einfacher, da es auf TCP aufsetzt und du dir so sehr viel Arbeit ersparen könntest.
 
Nein, mein Zielhost unterstützt nur COTP und H1.

Komme nicht so recht mit dem Socket klar,... TCPclient war ja noch einfach, kommuniziert auch aber instabil.

Nun brauch ich eine BEispiel-Source, die mir weiterhilft, eines der gezeigten Protokolle nach zu bilden, bzw. die Antworten ein zu lesen, den Rest dürfte ich dann schon hinbekommen.

Wenn ich hier schnell zu einem Ziel komme, dann darfst mir Deine Kontonummer nennen... Ich weis zwar noch nicht was es mir wert ist, aber wenn das hier klappt, dann werd ich was für berappen, ...

LG D12
 
Der TcpClient ist schon stabil, wenn man sauber damit umgeht, aber wie gesagt, den kannst du dir aus dem Kopf schlagen, weil dir das nicht weiterhilft. COTP hat mit TCP nichts zu tun (siehe http://wiki.ethereal.com/COTP).

COTP basiert zudem auf CLNP und nicht wie TCP auf IP. Ergo musst du schon weiter unten ansetzen. Soweit ich jedoch gesehen habe, scheint es einige Libraries zu geben, die CLNP unterstützen (Xceed Winsock Library). Du solltest dir diese vielleicht einmal ansehen, sonst wirst die nächsten zwei Monate nichts anderes tun, als eigene Protokolle zu implementieren.

Noch ein heisser Tipp: Guck dir mal die OSI-Schichten an. Da scheinst du noch Schwächen zu haben. Ach ja, und die ISO-Schichten wären auch net so blöd.
 
:O( dann denke ich das ich zum WE wieder arbeitslos bin, im ganzen Internet ist das so dokumentiert, scheinbar ist keiner in der Lage das mal zusammenhängend an einem einfachen Beispiel zu dokumentieren.

Ich kämpfe mich grad durch die MSDN durch...

Und hab grad den Socket.Connect(EPendpoint), was ist ein Ependpoint und dann noch die Socket-Flags, etc... da ist alles aufgelistet, aber eine Erklärung hat man sich bei MIcrosoft gespart. Da kann man nur die Krise bekommen, wenn man seit Tagen mit dem Mist beschäftigt ist und nicht mal eine einfache Komkmunikation zustande bekommt.

Nun wäre ein Quellcode, der einen Socket erstellt, der mit Ipirgendwas auf Port xy mit zusätzlichem ByteArray was sendet, ganz nützlich, aber zu dem Thema findet man nur Seitenlange codes, die nicht komentiert sind und wo man die einzelnen Eigenschaften nirgendwo erklärt findet. *grummel*
 
By The Way, was nützt es mir die OSI/ISO Schichten noch mal zu lesen, wenn ich nicht mal ein beispiel finde wie ich da wo reinfunken kann.... Und gelesen habe ich in den letzten Tagen eine Menge. Auch zu OSI/ISO.... Aber nix was wirklich weiterhilft...
 
Du hast es nicht verstanden. Zurück zum Start und kassiere 100.

Die Protokolle die du benötigst kann .NET nicht (zumindest hätte ihc keinen Hinweis darauf gefunden).

Dann solltest du dir ISO/OSI doch nochmal angucken, weil dir die Grundlagen der Netzwerk-Kommunikation fehlen. Ohne diese Grundlagen wirst du es nicht schaffen, hier etwas sinnvolles zu erreichen.

Du willst eine Kommunikation, die nicht auf IP basiert. Daher solltest du dich (bevor du Informationen über Endpoints etc. suchst) mal erkundigen, wie du eine Kommunikation via .NET über das Protokoll zusammenbringst, die du brauchst.

Eventuell hilft es auch, wenn du bei deinem Hersteller nachfragst, wie sie mit ihren Dingern kommunizieren bzw. ob sie dir da weiterhelfen können.

Des weiteren: was is eine S5 ?

Du gräbst da eindeutig an den falschen Stellen. Anstatt jetzt auf uns/mich sauer zu sein, solltest du dir das genau durchlesen was ich dir schreibe und auch beherzigen/verfolgen. Vielleicht solltest du auch mit dienen Problemen zu deinem Chef gehen. Wenn er dich für ein nicht triviales Problem feuert, dann kannst eh froh sein. Immerhin scheint das nichts zu sein, was in ein paar Tagen fertig sein kann.

Und hast du dir die Library von XCEED angeguckt? Ich getrau mich wetten, dass du es dir nichmal angesehen hast.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück