Sie sind auf Seite 1von 10

Visualisieren mit VB.

Net und LibNoDave

1 / 10

Inhaltsverzeichnis 1 Visualisieren mit VB.Net und LibNoDave ...................................................................................... 1 2 Neues VB.Net-Projekt mit Libnodave-Modul anlegen .................................................................. 1 3 Verbindungsaufbau und -abbau mit LibNoDave ........................................................................... 2 3.1 Verbindungsaufbau zu einer S7-CPU mit MPI-LAN-Kabel oder zu ACCONtrol ........................ 2 3.1.1 Verbindungsaufbau mit dem Protokoll ISO over TCP ...................................................... 3 3.2 Verbindungsaufbau zu einer S7-CPU mit den PC-Adaptern der Fa. Siemens .......................... 3 3.2.1 Verbindungsaufbau mit dem MPI-Protokoll...................................................................... 3 3.3 Verbindungsabbau (bei den Protokollen MPI, MPI2 und ISO-over-TCP) .................................. 4 4 S7-Speicherbereiche lesen und schreiben mit LibNoDave ......................................................... 4 4.1 S7-Speicherbereiche lesen mit LibNoDave ................................................................................ 4 4.1.1 ReadBits-Methode ............................................................................................................ 5 4.1.2 Auslesen der Bits eines Bytes .......................................................................................... 5 4.1.3 ReadBytes-Methode zum Lesen von 8-Bit-Speichern ..................................................... 6 4.1.4 ReadBytes-Methode zum Lesen von 16-Bit- und 32-Bit-Speichern ................................ 6 4.1.5 ReadBytes-Methode zum Lesen zusammenhngender Speicherbereiche ..................... 6 4.1.6 ReadManyBytes-Methode zum Lesen groer Speicherbereiche .................................... 7 4.2 In S7-Speicherbereiche schreiben mit LibNoDave ..................................................................... 7 4.2.1 WriteBits-Methode ............................................................................................................ 8 4.2.2 WriteBytes-Methode zum Schreiben von 8-Bit-Speichern ............................................... 8 4.2.3 WriteBytes-Methode zum Schreiben von 16-Bit- und 32-Bit-Speichern .......................... 8 4.3 Little Endian und Big Endian ...................................................................................................... 9 5 Erkennen eines Verbindungsabbruchs ....................................................................................... 10

Visualisieren mit VB.Net und LibNoDave1

Zur Visualisierung eines Prozesses mittels PC werden hufig OPC-Server benutzt, fr deren Benutzung in der Regel erhebliche Lizenzgebhren anfallen. Seit einiger Zeit gibt es eine kostenfreie Mglichkeit. Die libnodave.dll ermglicht die Herstellung von kostenfreien Verbindungen zwischen einer S7-300/400 und einem Windows-PC. Die libnodave.dll stellt das Interface zur Kommunikation mit einer Siemens-SPS dar. LibNoDave bietet zwar nicht den Komfort, den kommerzielle OPC-Server bieten, wie etwa ein fertiges ActiveX-Control, das einfach nur in die Software eingefgt werden muss und mit minimalem Aufwand konfiguriert ist, bringt aber nahezu das gleiche Leistungsspektrum mit. Der geringe Mehraufwand bei der Programmierung ist aber auf jeden Fall durch die Leistungsfhigkeit und die entfallenden Lizenzgebhren gerechtfertigt. Im Folgenden soll Einsteigern ein kleiner Einblick in die Benutzung der libnodave.dll in Verbindung mit VB.Net gegeben werden. LibNoDave wurde an der ???? in folgenden Konstellationen erfolgreich eingesetzt: Verbindungs-Hardware Siemens PC-Adapter 6ES7 901-2BF00-0AA0 Siemens: PC-Adapter 6ES7 972-0CA22-0XA0 Siemens: PC-Adapter 6ES7 972-0CB20-0XA0 Prozessinformatik: MPI-LAN-Kabel 9352 Deltalogic: ACCONtrol (S7-Testumgebung) PC-Schnittstelle COM1, COM2 COM1, COM2 USB RJ45 (Ethernet) 127.0.0.1 (virtuell) Protokolle MPI, MPI2, S7Online MPI, MPI2, S7Online S7Online ISO-over-TCP ISO-over-TCP

Tabelle 1 An der ???? eingesetzte Verbindungs-Hardware und ihre Protokolle

Neues VB.Net-Projekt mit Libnodave-Modul anlegen

Um die libnodave.dll fr die Kommunikation mit einer S7-300/400-SPS nutzen zu knnen, werden alle Konstanten, Prozeduren und Funktionen, die die Verbindung zur libnodave.dll herstellen, in einem Modul mit dem Namen LibnodaveModul.vb zusammengefasst. Der LibnodaveModul.vb muss in Ihrem VB-Projektordner liegen. Im LibnodaveModul.vb finden Sie auch eine kurze Beschreibung smtlicher Konstanten, Prozeduren und Funktionen, die bei der Kommunikation mit der libnodave.dll eingesetzt werden. Die libnodave.dll muss sich im Ordner ...\Windows\sytem32\ befinden.
Diese Beschreibung von LibNoDave fr den Einsatz mit VB.Net wurde in ihrer ursprnglichen Fassung von Herrn A. Helmis erstellt. Die Beschreibung wurde durch Earny abgendert und ergnzt.
1

Visualisieren mit VB.Net und LibNoDave

2 / 10

Bild 1 Libnodave-Modul mit seinen Konstanten, Prozeduren und Funktionen

Verbindungsaufbau und -abbau mit LibNoDave


Kommentar ffnen einer seriellen Verbindung oder einer ISO-over-TCPVerbindung; Schlieen einer Verbindung Reprsentiert die physikalische Verbindung zu einer SPS oder einem Netzwerk von SPSen Aufbau bzw. Abbau der Verbindung zu einem bestimmten Interface oder Adapter Angaben ber die vorhandene CPU Aufbau bzw. Abbau der Verbindung zu einer bestimmten CPU Freigabe des von dc belegten Speichers beim Verbindungsabbau, Freigabe des von di belegten Speichers beim Verbindungsabbau

Funktionen setPort, openSocket, closePort, openS7Online, closeS7online daveNewInterface daveInitAdapter, daveDisconnectAdapter daveNewConnection daveConnectPLC, daveDisconnectPLC daveFree(dc), daveFree(di)

Tabelle 2a Funktionen von LibNoDave fr den Verbindungsaufbau und Verbindungsabbau ph (peer handle): beinhaltet alle Informationen zu den ein- und ausgehenden Kommunikationskanlen; Rckgabewert von openSocket, setPort, closePort; ph muss grer als 0 und vom Datentyp Integer sein. di (dave interface handle): reprsentiert die physikalische Verbindung zu einer SPS oder einem Netzwerk von SPSen und beinhaltet alle Eigenschaften, die im Netzwerk gelten; di ist der Rckgabewert von daveNewInterface und ist vom Datentyp Integer. dc (dave connection handle): reprsentiert die Verbindung zu einer bestimmten CPU und beinhaltet alle Informationen, die diese CPU beschreiben; dc ist der Rckgabewert von daveNewConnection und ist vom Datentyp Integer. res: Rckgabewert von daveInitAdapter, daveConnectPLC, daveDisconnectPLC, daveDisconnectAdapter, closePort; res muss stets 0 und vom Datentyp Integer sein. Tabelle 2b Wichtige Variablen fr den Verbindungsaufbau und Verbindungsabbau mit LibNoDave

3.1

Verbindungsaufbau zu einer S7-CPU mit MPI-LAN-Kabel oder zu ACCONtrol

Fr den Verbindungsaufbau zu einer S7-CPU mit Hilfe eines MPI-LAN-Kabels der Fa. Prozessinformatik oder zu ACCONtrol (Testumgebung fr S7-Programme von Deltalogic) wird das ISO-over-TCPProtokoll eingesetzt. Die vorhandenen MPI-LAN-Kabel der Fa. Prozessinformatik haben die IPAdressen 192.168.53.51, 192.168.53.52 und 192.168.53.53. Die IP-Adresse der ACCONtrol-CPU ist 127.0.0.1. Die IP-Adresse wird als String bergeben.

Visualisieren mit VB.Net und LibNoDave

3 / 10

Bild 2 Verbindungsaufbau zu ACCONtrol (127.0.0.1) oder zu einer S7-CPU mit dem MPI-LAN-Kabel unter Verwendung des ISO-over-TCP-Protokolls

3.1.1

Verbindungsaufbau mit dem Protokoll ISO over TCP

Dim Port As Integer = 102, IP As String Dim Rack As Integer = 0, Slot As Integer = 2 Dim MPIAdressLocal As Integer = 0, MPIAdressPLC As Integer = 2 IP = cbxIP.Text ph = openSocket(Port, IP) di = daveNewInterface(ph, ph, "IF1", MPIAdressLocal, daveProtoISOTCP, daveSpeed187k) res = daveInitAdapter(di) dc = daveNewConnection(di, MPIAdressPLC, Rack, Slot) res = daveConnectPLC(dc)

3.2

Verbindungsaufbau zu einer S7-CPU mit den PC-Adaptern der Fa. Siemens

Fr den Verbindungsaufbau zu einer S7-CPU mit den PC-Adaptern zum Anschluss an die COMSchnittstelle des PCs kann das MPI-Protokoll eingesetzt werden. An der ???? existieren PC-Adapter mit bertragungsraten von 19200 Bit/s und 38400 Bit/s. Diese Adapter knnen mit Rechnern eingesetzt werden, die ber eine serielle Schnittstelle (COM) verfgen. Der COM-Port und die Baudrate werden als String bergeben. USB-Adapter der Fa. Siemens knnen mit dem S7Online-Protokoll eingesetzt werden.

Bild 3 Verbindungsaufbau ber die COM1-Schnittstelle mit den PC-Adaptern der Fa. Siemens. Von den PC-Adaptern zum Anschluss an die COM-Ports eines PCs werden die Protokolle MPI, MPI2 und S7Online untersttzt.

3.2.1

Verbindungsaufbau mit dem MPI-Protokoll

Dim Baud As String, Port As String Dim Rack As Integer = 0, Slot As Integer = 2 Dim MPIAdressPLC As Integer = 2, MPIAdressLocal As Integer = 0 Port = cbxCOM.Text Baud = cbxSpeed.Text ph = setPort(Port, Baud, Asc("O")) di = daveNewInterface(ph, ph, "IF1", MPIAdressLocal, daveProtoMPI, daveSpeed187k) Call daveSetTimeout(di, 1000000) res = daveInitAdapter(di) dc = daveNewConnection(di, MPIAdressPLC, Rack, Slot) res = daveConnectPLC(dc)

Visualisieren mit VB.Net und LibNoDave

4 / 10

3.3

Verbindungsabbau (bei den Protokollen MPI, MPI2 und ISO-over-TCP, nicht bei S7Online)

res = daveDisconnectPLC(dc) Call daveFree(dc) dc = 0 res = daveDisconnectAdapter(di) Call daveFree(di) di = 0 res = closePort(ph) ph = 0

S7-Speicherbereiche lesen und schreiben mit LibNoDave


Wertebereich -128 bis 127 -32.768 bis 32.767 -2.147.483.648 bis 2.147.483.647 -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 0 bis 255 0 bis 65.535 0 bis 4.294.967.296 0 bis 18.446.744.073.709.551.616 -3,402823E38 bis 3,402823E38 -1,79769313486231E308 bis 1,79769313486231E308 True (wahr) oder False (falsch) Beschreibung 8-Bit-Ganzzahl 16-Bit-Ganzzahl 32-Bit-Ganzzahl 64-Bit-Ganzzahl Lnge 1 Byte 2 Byte 4 Byte 8 Byte S7-Datentyp / Integer Double Integer /

VB.NetDatentyp SByte Short Integer Long

Byte UShort UInteger ULong Single Double Boolean

vorzeichenlose 8-Bit-Ganzzahl vorzeichenlose 16-Bit-Ganzzahl vorzeichenlose 32-Bit-Ganzzahl vorzeichenlose 64-Bit-Ganzzahl Gleitkommazahl einfacher Genauigkeit Gleitkommazahl doppelter Genauigkeit Wahrheitswerte

1 Byte 2 Byte 4 Byte 8 Byte 4 Byte 8 Byte 2 Byte

Byte / / / Real / Bool

Tabelle 3 VB.Net- und S7-Datentypen

4.1

S7-Speicherbereiche lesen mit LibNoDave

Die daveReadBytes-Methode liest digitale Speicher der S7-CPU und schreibt die Werte in ein VBByte-Array. Es existieren drei Mglichkeiten zum Auslesen des Byte-Arrays: Lesen mit Zeiger, Lesen bei einer bestimmten Position und Lesen mit Hilfe eines VB-Pufferspeichers (buf). In dieser Beschreibung findet nur die dritte Methode Verwendung. Tabelle 4 gibt einen berblick ber die elementaren S7-Speicherbereiche, die mit LibNoDave ausgelesen werden knnen. Hinweis: Beim Lesen von 16-Bit- und 32-Bit-Speicherbereichen muss mit Hilfe der daveGet...-Funktion eine Byte-Drehung (Big Endian Little Endian) herbeigefhrt werden. Speicherbereiche Merker Eingnge Ausgnge Timer Zhler Datenbausteine Peripherieeingnge LibNoDave daveFlags daveInputs daveOutputs daveTimer daveCounter daveDB daveP Beispiel MD23 EW12 AB3 T1 C2 DB12.DBD8 PEW288 Beispielcode fr das Lesen von S7-Speicher daveReadBytes(dc, daveFlags, 0, 23, 4, buf(0)) daveReadBytes(dc, daveInputs, 0, 12, 2, buf(0)) daveReadBytes(dc, daveOutputs, 0, 3, 1, buf(0)) daveReadBytes(dc, daveTimer, 0, 1, 2, buf(0)) daveReadBytes(dc, daveCounter, 0, 2, 2, buf(0)) daveReadBytes(dc, daveDB, 12, 8, 4, buf(0)) daveReadBytes(dc, daveP, 0, 288, 2, buf(0))

Tabelle 4 S7-Speicherbereiche und LibNoDave-Methoden zum Auslesen ihrer Werte;

Visualisieren mit VB.Net und LibNoDave

5 / 10

Hinweise: Der Rckgabewert der LibNoDave-Funktion daveReadBytes(...) muss stets 0 sein, sonst ist ein Fehler aufgetreten. Der Rckgabewert kann im VB-Programm zur Programmsteuerung eingesetzt werden. Die DB-Nummer (3. Argument) wird nur beim Auslesen von Datenbausteinen angegeben. Bei den anderen Speicherbereichen wird dieses Argument stets auf 0 gesetzt.
Lesen mit Zeiger daveGetU8(dc) daveGetS8(dc) daveGetU16(dc) daveGetS16(dc) daveGetU32(dc) daveGetS32(dc) daveGetFloat(dc) daveGetSeconds(dc) Lesen von Position daveGetU8At(dc, x) daveGetS8At(dc, x) daveGetU16At(dc, x) daveGetS16At(dc, x) daveGetU32At(dc, x) daveGetS32At(dc, x) daveGetFloatAt(dc, x) daveGetSecondsAt(dc, x) Lesen aus Puffer daveGetU8from(buf(x)) daveGetS8from(buf(x)) daveGetU16from(buf(x)) daveGetS16from(buf(x)) daveGetU32from(buf(x)) daveGetS32from(buf(x)) daveGetFloatfrom(buf(x)) daveGetSecondsfrom(buf(x)) Vorzeichen Nein Ja Nein Ja Nein Ja Ja Nein VB.Net Datentyp Byte SByte UShort Short UInteger Integer Single Single

Tabelle 5 LibNoDave-Methoden zum Auswerten der mit daveReadBytes gelesenen Werte Hinweis: Werden nur einzelne Speicherbereiche gelesen, so hat x den Wert 0.

4.1.1 ReadBits-Methode Die ReadBits-Methode dient dem Auslesen einzelner Bits aus der S7-CPU. Sobald mehr als ein Bit gelesen werden soll, ist von dieser Methode abzuraten. Es dauert relativ lange, fr jedes Bit eine einzelne Anfrage an die SPS zu senden. Schneller geht es, ein ganzes Byte oder mehrere Bytes mittels daveReadBytes auszulesen und die einzelnen Bit-Werte dann in VB zu ermitteln (siehe unten). Allgemein: res = daveReadBits(dc, Speicherbereich, DB-Nummer, Bitadresse, Lnge in Bytes, Lesepuffer(0)) Beispiel: Der Wert des Merker M37.5 soll gelesen werden. Die absolute Bitadresse = 37 * 8 + 5 = 301. Der Wert wird zunchst in den Puffer buf(0) geschrieben und anschlieend in die TextBox. Nach dem Schreibvorgang steht der Wert 0 oder 1 in der TextBox. Dim buf(0) As Byte res = daveReadBits(dc, daveFlags, 0, 301, 1, buf(0)) txtM37_5Wert.Text = buf(0) 4.1.2 Auslesen der Bits eines Bytes Wenn Sie die booleschen Werte mehrerer Bits wissen mssen, bietet es sich an, mit daveReadBytes grere Bereiche auszulesen und diese dann im VB-Programm auszuwerten. Dies geht schneller, als mehrere Bits einzeln mit daveReadBits abzufragen. Es soll die Wertigkeit der einzelnen Bits des EB1 festgestellt werden. Private Sub btnEB1Lesen_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnEB1Lesen.Click Dim buf(0) As Byte, B As Byte, Bit(7) As Boolean res = daveReadBytes(dc, daveInputs, 0, 1, 1, buf(0)) B = daveGetU8from(buf(0)) Call ByteToBit(B, Bit) End Sub Public Sub ByteToBit(ByVal B As Byte, ByVal Bit() As Boolean) Dim Maske As Integer = 1, i As Integer For i = 0 To 7 Bit(i) = Maske And B Maske = Maske * 2 Next End Sub

Visualisieren mit VB.Net und LibNoDave

6 / 10

4.1.3

ReadBytes-Methode zum Lesen von 8-Bit-Speichern

Allgemein: Dim Lesepuffer(0) As Byte Rckgabewert = daveReadBytes(dc, Speicherbereich, DB-Nummer, Anfangsbyte, Lnge in Bytes, Lesepuffer(0)) Beispiel: Lesen des Ausgangsbytes AB24: Dim buf(0) As Byte res = daveReadBytes(dc, daveOutputs, 0, 24, 1, buf(0)) Beispiel: Lesen des Eingangsbytes EB13: Dim buf(0) As Byte res = daveReadBytes(dc, daveInputs, 0, 13, 1, buf(0))

4.1.4 ReadBytes-Methode zum Lesen von 16-Bit- und 32-Bit-Speichern Die Funktion daveReadBytes(...) liest den Wert aus dem angegebenen S7-Speicher und schreibt ihn in ein VB-Byte-Array. Die Funktion daveGet...(...) konvertiert den Wert aus dem VB-ByteArray von Big Endian nach Little Endian und bergibt ihn an eine VB-Variable oder an ein VBObjekt. Beispiel: 16-Bit-Integer-Wert aus dem S7-Speicher MW30 lesen und an eine Short-Variable (VB) bergeben: Dim buf(1) As Byte, Dim shoVar As Short res = daveReadBytes(dc, daveFlags, 0, 30, 2, buf(0)) shoVar = daveGetS16from(buf(0)) Beispiel: 32-Bit-Integer-Wert aus dem S7-Speicher ED22 lesen und an eine Integer-Variable (VB) bergeben: Dim buf(3) As Byte, Dim intVar As Integer res = daveReadBytes(dc, daveInputs, 0, 22, 4, buf(0)) intVar = daveGetS32from(buf(0)) Beispiel: 32-Bit-Real-Wert aus dem S7-Speicher DB25.DBD16 lesen und an eine Single-Variable (VB) bergeben: Dim buf(3) As Byte, Dim sngVar As Single res = daveReadBytes(dc, daveDB, 25, 16, 4, buf(0)) sngVar = daveGetFloatfrom(buf(0))

4.1.5 ReadBytes-Methode zum Lesen zusammenhngender Speicherbereiche Wenn Sie zusammenhngende Speicherbereiche lesen mssen, bietet es sich an, mit daveReadBytes zunchst den gesamten zusammenhngenden Speicher der S7 zu lesen und die Werte dann in ein VB-Byte-Array ausreichender Gre zu schreiben. Anschlieend wird der Inhalt des Byte-Arrays im VB-Programm ausgewertet. Dies geht schneller, als die Speicherbereiche einzeln einzulesen und dann weiterzuverarbeiten. Die daveGet...from(...)-Methode bernimmt die Konvertierung von Big Endian nach Little Endian bei den 16- und 32-Bit-Werten. Mit Hilfe der daveReadBytes-Methode knnen Sie je nach verwendeter CPU bis zu 220 Bytes je Anfrage empfangen. Falls Sie grere Datenmengen auslesen wollen, knnen Sie das mit der daveReadManyBytes-Methode tun (siehe unten). LibNoDave schreibt den aus der S7-CPU gelesenen Wert zunchst in den Lesepuffer. Dieser muss vorab als Array von Bytes deklariert sein (z. B. Dim buf(n) As Byte). Anschlieend mssen die Werte aus dem Lesepuffer ausgelesen und weiterverarbeitet werden. Die Gre des bentigten Lesepuffers n richtet sich nach der Anzahl der einzulesenden Bytes. Damit betrgt die Mindestgre fr den Lesepuffer bei der Deklaration: n = Anzahl der einzulesenden Bytes 1 (!) Im nachfolgenden Beispiel sollen 12 Bytes eingelesen werden. Deshalb besitzt n den Wert 11. Beispiel: Es soll der zusammenhngende Speicherbereich bestehend aus MB20, MW22 (INT), MD24 (DINT) und MD28 (REAL) zunchst gelesen und dann in ein VB-Byte-Array geschrieben werden. Anschlieend wird der Lesepuffer ausgewertet und die einzelnen Werte in Textboxen geschrieben.

Visualisieren mit VB.Net und LibNoDave

7 / 10

Bemerkung: Das MB21 liegt zwar innerhalb des zusammenhngenden Speicherbereichs. Sein Wert sei aber nicht von Interesse und werde deshalb nicht weiterverarbeitet: Dim buf(11) As Byte res = daveReadBytes(dc, daveFlags, 0, 20, 12, buf(0)) txtMB20Wert.Text = daveGetU8from(buf(0)) txtMW22Wert.Text = daveGetS16from(buf(2)) txtMD24Wert.Text = daveGetS32from(buf(4)) txtMD28Wert.Text = daveGetFloatfrom(buf(8))

4.1.6 ReadManyBytes-Methode zum Lesen groer Speicherbereiche Mit der daveReadManyBytes-Methode knnen auch zusamenhngende Speicherbereiche, die grer als 220 Bytes sind, gelesen werden. Diese Methode eignet sich somit besonders gut zum Auslesen von Datenbausteinen einer S7-CPU. Beispiel: Wenn der Button btnWerteLesen gedrckt wird, werden die ersten 2000 Bytes aus dem Datenbaustein DB10 gelesen. Diese 2000 Bytes setzen sich im vorliegenden Fall aus 1000 einzelnen 16-Bit-Integer-Werten zusammen und sollen als zusammenhngender Datenbereich von der daveReadManyBytes-Methode gelesen und in den Lesepuffer Buffer(1999) geschrieben werden. Nach Beendigung des Lesevorgangs knnen die 1000 Integer-Werte in die Tabelle einer ExcelArbeitsmappe geschrieben werden. Der Lesepuffer Buffer(1999) wurde deshalb auerhalb der beiden VB-Prozeduren deklariert! Dim Buffer(1999) As Byte Private Sub btnWerteLesen_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnWerteLesen.Click res = daveReadManyBytes(dc, daveDB, 10, 0, 2000, Buffer(0)) End Sub Private Sub btnExcelSchreiben_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnExcelSchreiben.Click Dim i As Integer For i = 0 To 999 Exc.Worksheets(1).Cells(i + 2, 2).value = daveGetS16from(Buffer(i * 2)) Next End Sub

4.2

In S7-Speicherbereiche schreiben mit LibNoDave

Die daveWriteBytes-Methode ermglicht es, in digitale Speicher der S7-CPU zu schreiben. Vor dem Schreibvorgang mssen 16-Bit- und 32-Bit-Werte mit Hilfe der davePut...(...)-Funktion eine Byte-Drehung von Little Endian nach Big Endian erfahren. Fr die Zwischenspeicherung wird wieder ein Pufferspeicher buf eingesetzt. Tabelle 6 gibt einen berblick ber die LibNoDave-Funktionen zum Konvertieren eines Wertes vom Little-Endian-Format ins Big-Endian-Format. Anschlieend kann der Wert gem Tabelle 7 aus dem Puffer buf ausgelesen und mit daveWriteBytes(...) in den Speicher der S7-CPU geschrieben werden. Der Rckgabewert res muss stets 0 sein, sonst ist ein Fehler aufgetreten. Der Wert von res kann im VB-Programm zur Programmsteuerung eingesetzt werden. Die DB-Nummer (3. Argument) wird nur beim Auslesen von Datenbausteinen angegeben. Bei den anderen Speicherbereichen wird dieses Argument stets auf 0 gesetzt.
Schreiben in Puffer Vorzeichen VB.Net Datentyp Byte Short Integer Single

davePut8(buf(0), Wert)* davePut16(buf(0), Wert) davePut32(buf(0), Wert) davePutFloat(buf(0), Wert)

Nein Ja Ja Ja

Tabelle 6 LibNoDave-Methoden zum Konvertieren von Little Endian nach Big Endian * Diese Konvertierung kann entfallen.

Visualisieren mit VB.Net und LibNoDave

8 / 10

Speicherbereiche Merker Eingnge Ausgnge Timer Zhler Datenbausteine Peripherieausgnge

LibNoDave daveFlags daveInputs daveOutputs daveTimer daveCounter daveDB daveP

Beispiel MD23 EW12 AB3 T1 C2 DB12.DBD8 PAW288

Beispielcode fr das Lesen von S7-Speicher daveWriteBytes(dc, daveFlags, 0, 23, 4, buf(0)) daveWriteBytes(dc, daveInputs, 0, 12, 2, buf(0)) daveWriteBytes(dc, daveOutputs, 0, 3, 1, buf(0)) daveWriteBytes(dc, daveTimer, 0, 1, 2, buf(0)) daveWriteBytes(dc, daveCounter, 0, 2, 2, buf(0)) daveWriteBytes(dc, daveDB, 12, 8, 4, buf(0)) daveWriteBytes(dc, daveP, 0, 288, 2, buf(0))

Tabelle 7 S7-Speicherbereiche sowie LibNoDave-Methoden zum Auslesen des Pufferspeichers buf(0) und Schreiben des Wertes in die S7-CPU

4.2.1 WriteBits-Methode Mit der daveWriteBits-Methode kann der boolesche Wert eines einzelnen Bits geschrieben werden. Vorteil: Die angrenzenden Bits bleiben unverndert. Allgemein: res = daveWriteBits(dc, Speicherbereich, DB-Nummer, Bitadresse, Lnge in Bytes, 0/1) Beispiel: Die Methode daveWriteBits schreibt den Wert 0 in den Merker M20.2. Die absolute Adresse des Merkers errechnet sich mit 20 * 8 + 2 = 162: res = daveWriteBits(dc, daveFlags, 0, 162, 1, 0) Beispiel: Die Methode daveWriteBits schreibt den Wert 1 in den Ausgang A7.4. Die absolute Adresse des Ausgangs errechnet sich mit 7 * 8 + 4 = 60: res = daveWriteBits(dc, daveOutputs, 0, 60, 1, 1)

4.2.2 WriteBytes-Methode zum Schreiben von 8-Bit-Speichern Die daveWriteBytes-Methode ermglicht das Schreiben in die digitalen Speicher der S7-CPU. Das Schreiben einzelner Byte-groer Speicher kann ohne die Verwendung eines VB-Pufferspeichers erfolgen. Achten Sie darauf, dass Sie nicht ungewollt Bits berschreiben, die nicht gendert werden sollen! Allgemein: Rckgabewert = daveWriteBytes(dc, Speicherbereich, DB-Nummer, Anfangsbyte, Lnge in Bytes, Wert) Beispiel: Schreiben des Wertes 123 in das Ausgangsbytes AB24: res = daveWriteBytes(dc, daveOutputs, 0, 24, 1, 123)

4.2.3 WriteBytes-Methode zum Schreiben von 16-Bit- und 32-Bit-Speichern Die Funktion davePut...(buf(0), Wert) liest den Wert aus dem rechten Argument, konvertiert den angegebenen Wert von Little Endian nach Big Endian und schreibt ihn in ein VB-Byte-Array. Die Funktion daveWriteBytes(....) liest den Wert aus dem VB-Byte-Array und schreibt ihn in den angegebenen S7-Speicher. Beispiel: Wert aus der Textbox "EingabeWert" lesen und als 16-Bit-Short-Wert ins MW22 der S7-CPU schreiben: Dim buf(1) As Byte res = davePut16(buf(0), EingabeWert.Text) res = daveWriteBytes(dc, daveFlags, 0, 22, 2, buf(0)) Beispiel: Zahlenwert 123456789 als 32-Bit-Integer-Wert in den Speicher AD24 der S7-CPU schreiben: Dim buf(3) As Byte res = davePut32(buf(0), 123456789) res = daveWriteBytes(dc, daveOutputs, 0, 24, 4, buf(0))

Visualisieren mit VB.Net und LibNoDave

9 / 10

Beispiel: Zahlenwert 384,56 als 32-Bit-Single-Wert in den Speicher DB7.DBD12 der S7-CPU schreiben: Dim buf(3) As Byte res = davePutFloat(buf(0), 384,56) res = daveWriteBytes(dc, daveDB, 7, 12, 4, buf(0))

4.3

Little Endian und Big Endian

Im folgenden Beispiel wird die Ganzzahl 439.041.101 als 32-Bit-Integer-Wert gespeichert (Binr: 00011010 00101011 00111100 01001101, hexadezimal: 1A 2B 3C 4D). Die Speicherung erfolgt ab einer hypothetischen Speicheradresse 10000 und den darauf folgenden drei Bytes. Beispiel: Speicherung eines 32-Bit-Integer-Wertes Big Endian Adresse Hex Dez 10000 10001 10002 10003 1A 2B 3C 4D 26 43 60 77 Binr 00011010 00101011 00111100 01001101 Little Endian Hex Dez 4D 3C 2B 1A 77 60 43 26 Binr 01001101 00111100 00101011 00011010 Middle Endian Hex Dez 2B 1A 4D 3C 43 26 77 60 Binr 00101011 00011010 01001101 00111100

Tabelle 8 Big Endian, Little Endian und Middle Endian Quelle: Internet-Lexikon Wikipedia, Dez. 2009 Wenn die Speicherung in der Reihenfolge 1A 2B 3C 4D erfolgt, so entspricht dies Big Endian (das hchst signifikante Byte in der niedrigsten Speicheradresse). Die Speicherung in der umgekehrten Reihenfolge (4D 3C 2B 1A) entspricht Little Endian (das hchst signifikante Byte in der hchsten Speicheradresse). Einige ltere Systeme (z. B. PDP-11) speichern die Daten auch in der Reihenfolge 3C 4D 1A 2B oder auch 2B 1A 4D 3C. Dies wird als Middle Endian bezeichnet. Bemerkung: Wrde die 32-Bit-Ganzzahl 439.041.101 von einer S7-300/400-CPU (Big Endian) ohne Byte-Drehung auf einen Intel-Windows-PC (Little Endian) bertragen, so wrde ein Intel-Prozessor in diesen vier Bytes die Zahl 1.295.788.826 sehen!

Bild 4 Big Endian in der S7

Um die aus einer S7-CPU ausgelesenen Werte sinnvoll weiterverarbeiten zu knnen, bzw. um VBWerte im richtigen Format in die S7-Speicher schreiben zu knnen, muss man die S7-Speicherbereiche, die Datentypen und die Methoden zum Lesen bzw. Schreiben der Werte kennen (siehe Tab. 3, 4, 5, 6 und 7). Die Byte-Drehung ist bei allen 16-Bit- und 32-Bit-Datentypen zu beachten! In der S7-CPU wird das System Big Endian verwendet, whrend Intel Little Endian verwendet. Das bedeutet, dass Intel mit dem niederwertigsten Bit im niederwertigsten Byte zu zhlen beginnt, wohingegen das niederwertigste Bit bei einer S7-SPS im hchstwertigen Byte steht. Bemerkungen: Wenn Sie die Funktion daveGet... nach dem Lesen benutzen, wandelt LibNoDave ihren Big- Endian-Wert automatisch in einen Little-Endian-Wert um. Wenn Sie die Funktion davePut... vor dem Schreiben benutzen, wandelt LibNoDave ihren LittleEndian-Wert automatisch in einen Big-Endian-Wert um.

Visualisieren mit VB.Net und LibNoDave

10 / 10

Erkennen eines Verbindungsabbruchs

Ein unerkannter Verbindungsabbruch zwischen einer CPU und der zugehrigen Visualisierung stellt eine Gefahr dar, weil die eingelesenen Variablen-Werte flschlicherweise als 0-Werte interpretiert werden knnen und Schreibbefehle aus der Visualisierung die Steuerung nicht mehr erreichen. Lebensbitprinzip: Bei dieser Methode setzt die CPU im OB1 zyklisch ein einzelnes Bit (z. B. M90.0) auf den Wert 1. Der Wert dieses Bits wird innerhalb einer Timer-Prozedur in der Visualisierung abgefragt. Falls das Lebensbit den Wert 1 hat, ist eine Verbindung vorhanden. Der Wert von M90.0 wird anschlieend von der Visualisierung auf den Wert 0 gesetzt und in die CPU geschrieben. Dort wird der Wert bereits im nchsten SPS-Zyklus wieder auf 1 gesetzt. Liefert die Abfrage des Lebensbits in der Visualisierung einen Wert ungleich 1, so liegt ein Verbindungsabbruch vor, und es kann eine entsprechende Reaktion programmiert werden. Ein Zugriff auf die S7-Speicher darf nur mglich sein, wenn das Lebensbit den Wert 1 hat. Livebit-Prinzip: Private Sub Timer1_Tick(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles Timer1.Tick Dim buf(0) As Byte 'M90.0 = livebit; muss im OB1 zyklisch auf 1 gesetzt werden res = daveReadBits(dc, daveFlags, 0, 720, 1, buf(0)) If buf(0) = 1 Then res = daveWriteBits(dc, daveFlags, 0, 720, 1, 0) txtVerbindung.Text = "OK" txtVerbindung.BackColor = Color.Lime livebit = True Else livebit = False txtVerbindung.Text = "Beendet" txtVerbindung.BackColor = Color.Yellow Timer1.Enabled = False res = daveDisconnectPLC(dc) Call daveFree(dc) dc = 0 res = daveDisconnectAdapter(di) Call daveFree(di) di = 0 res = closePort(ph) ph = 0 End If End Sub