Step 7 Verbindung mit PC

AlexTh

Level-2
Beiträge
112
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

ich wollte mal etwas simples fragen, habe auch schon einige Beiträge gelesen, aber noch nicht das Richtige gefunden...

Ich möchte eine S7-300 mit einem Leitrechner verbinden, der Rechner soll nur den Inhalt diverser DBs darstellen.

Auf dem Leitrechner ist kein WinCC installiert, da ich denke, dass sich Lizenzkosten und Nutzen nicht decken.
Es könnte quasi jede x-beliebige Software zur Darstellung der Daten genutzt werden, eventuell auch etwas selbst programmiertes in VB.NET.

Hat jemand Beispiele oder kann mir grob erklären, wie ich dies am Besten umsetzen kann?

Hardwareaufbau:
S7-300 > CP343-1 Ethernet > Switch > Leitrechner


Grüße Alex
 
Hallo,
direkt Beispiele dafür wirst du wohl nicht bekommen.
Ein bißchen dazu schreiben kann ich schon.

Es gibt hier unterschiedliche Ansätze, die aber alle eines gemeinsam haben : du brauchst erstmal eine Ankopplung an die SPS.
Das könnte z.B. LibNoDave machen oder die Überarbeitung derselben von Jochen Kühner.
Dann gäbe es auch noch von Deltalogic das AGLink. Oder es gäbe von InoSoft das VisiWin (und sicherlich auch noch Weitere).
Die beiden letzt-genannten kosten beide Geld und auch nicht unerheblich (bei VisiWin liegst du in etwa bei dem, was eine gleiche Flex-Lizenz kosten würde) - du bist aber dadurch, dass alles unter .Net passiert hinsichtlich allem anderen, was die HMI angeht, wesentlich offener UND wesentlich flexibler.

Wenn du mir etwas mehr zu deinem Vorhaben schreibst dann kann ich auch mehr dazu schreiben ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Auf dem Leitrechner ist kein WinCC installiert, da ich denke, dass sich Lizenzkosten und Nutzen nicht decken.
Es könnte quasi jede x-beliebige Software zur Darstellung der Daten genutzt werden, eventuell auch etwas selbst programmiertes in VB.NET.

Nunja, solange Du das "selbst programmierte" nicht aus der Schublade ziehen kannst, bzw. Deine Arbeitszet nichts kostet, werden sich vor allem die Lizenzkosten nicht mit den Kosten der benötigten Arbeitszeit decken.

Je nach benötigter Funktionalität und notwendiger Verfügbarkeit werden für das "selbst gebastelte" sicherlich einige Mannstunden auflaufen.

Aber wie LL schon sagt, erkläre mal etwas konkreter, was und warum Du alles machen willst.

Gruß.F
 
@AlexTh

hast Du schon Programmiererfahrung und Dir fehlt nur noch die Information, wie Du die Daten in den PC bekommst?

Dann würde ich Dir die Snap7 Bibliothek von Davide Nardella empfehlen

http://snap7.sourceforge.net/

Das Paket enthält eine absolut saubere Dokumentation und viele Beispiele, auch im .NET Bereich.

Die Bibliothek wird unter der LGPL Angeboten.

Gruß, Andreas
 
Hallo,

ich will einfach nur ein paar Daten (Stückzahlen pro Tag / Schicht / Woche ..., Maschine in Betrieb, Maschine wartet, Maschinenstörung) darstellen.

Es ist keine Arbeitsaufgabe für mich, ich will es lediglich privat testen. Die Programmiererfahrung im Bereich Step 7 habe ich, in VB.NET bin ich noch nicht so fit.
Libnodave ist mir bekannt, hatte ich aber irgendwie ausgeblendet. Snap7 sagt mir gar nichts.
Ich hatte vor vielen Jahren über Prodave Daten über RS232 an ein VB6-Projekt übergeben, das halte ich jedoch für etwas altmodisch ;)

Vom Prinzip her fehlt mir jetzt das Wissen, wie ich es mit Libnodave oder Snap7 umsetzen könnte. Über CP343 habe ich noch nichts gemacht...

Der CP343 wird mir im Projekt so aufgeführt, dass ich dort theoretisch auch Bausteine erstellen könnte, wird das so gemacht oder bleibe ich in meinem Programm?
Wie werden die Daten definiert, die ich an den Rechner senden will? Einfach mit AG_SEND/AG_RECV ausgeben und empfangen?
Dann bräuchte ich theoretisch nur noch ein Beispiel für den Datenempfang am Rechner ... das Senden will ich momentan noch gar nicht probieren, lediglich das Empfangen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo

soll das ein Hobbyprojekt bleiben ? Dann arbeite Dich in libnodave o.ae ein.

Soll das später professionell werden nimm ein SCADA mit SQL Anbindung.

Für meine Anwendungen reicht ein AtomBox PC aus.
 
Falls deine Anlage ein "vernünftiges" Panel hat, dann kannst du auch mit Variablenarchiven deine Datenerfassung machen.
Die Variablenarchive kannst du dann auf ein Netzlaufwerk kopieren.
So hab ichs mal vor Jahren umgesetzt.
 
Hallo,

ich will einfach nur ein paar Daten (Stückzahlen pro Tag / Schicht / Woche ..., Maschine in Betrieb, Maschine wartet, Maschinenstörung) darstellen.

Es ist keine Arbeitsaufgabe für mich, ich will es lediglich privat testen. Die Programmiererfahrung im Bereich Step 7 habe ich, in VB.NET bin ich noch nicht so fit.
Libnodave ist mir bekannt, hatte ich aber irgendwie ausgeblendet. Snap7 sagt mir gar nichts.
Ich hatte vor vielen Jahren über Prodave Daten über RS232 an ein VB6-Projekt übergeben, das halte ich jedoch für etwas altmodisch ;)

Vom Prinzip her fehlt mir jetzt das Wissen, wie ich es mit Libnodave oder Snap7 umsetzen könnte. Über CP343 habe ich noch nichts gemacht...

Der CP343 wird mir im Projekt so aufgeführt, dass ich dort theoretisch auch Bausteine erstellen könnte, wird das so gemacht oder bleibe ich in meinem Programm?
Wie werden die Daten definiert, die ich an den Rechner senden will? Einfach mit AG_SEND/AG_RECV ausgeben und empfangen?
Dann bräuchte ich theoretisch nur noch ein Beispiel für den Datenempfang am Rechner ... das Senden will ich momentan noch gar nicht probieren, lediglich das Empfangen.

Hoert sich fuer mich so an, dass ein Basic- Panel von Siemens ausreicht... Warum muss es ein PC sein?
 
Vom Prinzip her fehlt mir jetzt das Wissen, wie ich es mit Libnodave oder Snap7 umsetzen könnte. Über CP343 habe ich noch nichts gemacht...

Der CP343 wird mir im Projekt so aufgeführt, dass ich dort theoretisch auch Bausteine erstellen könnte, wird das so gemacht oder bleibe ich in meinem Programm?
Wie werden die Daten definiert, die ich an den Rechner senden will? Einfach mit AG_SEND/AG_RECV ausgeben und empfangen?
Dann bräuchte ich theoretisch nur noch ein Beispiel für den Datenempfang am Rechner ... das Senden will ich momentan noch gar nicht probieren, lediglich das Empfangen.

Das ist mit Snap7 relativ einfach umzusetzen. Wenn Du den CP auf der S7-Seite ordnungsgemäß in die Hardwarekonfiguration und in die Station eingebunden hast (IP-Adresse nicht vergessen).

Der Rechner mit dem Du auf die Station zugreifen willst muss im gleichen IP-Bereich sein, z.B.: CP: 192.168.0.1, Rechner: 192.168.0.33, außerdem müssen beide per Kabel (direkt oder über Switch, Router, usw.) verbunden sein.
Dann musst Du verschiedene Befehle aus der Snap7.dll aufrufen. Ich schreibe Dir hier mal die grobe Reihenfolge auf, eine ausführliche Beschreibung findest Du in der Snap7-Doku.

1. Client erstellen:
Code:
S7Object Cli_Create();

2. Verbindung zur Steuerung (CPU) aufbauen:
Code:
int  Cli_ConnectTo(S7Object Client, const char *Address, int Rack, int  Slot);
(Slot ist der Steckplatz der CPU, nicht vom CP)

3. Zyklisch Daten auslesen in einen zuvor Reservierten Speicherbereich:
Wenn Du alle Daten in der CPU am Block in einem DB ablegst, kannst Du diesen Bereich sehr einfach über
Code:
int Cli_ReadArea(S7Object Client, int Area, int DBNumber, int Start, int Amount, int WordLen, void *pUsrData);
auslesen.
Wenn die Daten über mehrere DB's (oder andere Datenbereiche) verteilt sind musst Du
Code:
int Cli_ReadMultiVars(S7Object Client, PS7DataItem Item, int ItemsCount);
verwenden. Dieser Befehl ist etwas komplizierter, da Du erst ein strukturiertes Array für den Empfang der Daten anlegen musst.

Ich verwende leider kein VB.NET, sonst hätte ich Dir ein Beispiel zukommen lassen können, für PureBasic könnte ich Dir schnell ein Beispiel basteln.

Gruß, Andreas
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das ist mit Snap7 relativ einfach umzusetzen.
[...]
Der Rechner mit dem Du auf die Station zugreifen willst muss im gleichen IP-Bereich sein, z.B.: CP: 192.168.0.1, Rechner: 192.168.0.33, außerdem müssen beide per Kabel (direkt oder über Switch, Router, usw.) verbunden sein.
Bist Du sicher? S7-Verbindungen funktionieren auch über Router.

@Alex
Für EXCEL und Libnodave gibt es hier eine FAQ
Du könntest auch über eine TCP-Verbindung (siehe meine Signatur) Daten an einen TCP-Server (PC) senden. Dann brauchst Du keine Bibliothek für das S7-Protokoll.

Harald
 
Bist Du sicher? S7-Verbindungen funktionieren auch über Router.

@PN/DP: Ob Du mit Snap7 aus einem fremden Netz über einen Router auf die Station kommst kann ich Dir leider nicht verraten, da ich mit solchen Konstellationen noch keine Erfahrungen gesammelt habe (vielleicht geht das, wenn Du den Port 102 durchschleust), was aber bei Bedarf auf jeden Fall möglich ist, ist der Zugriff über einen VPN-Tunnel.
Ich glaube das ganze geht aber weit an den Anforderungen von Alex vorbei. Für mich hört sich das so an, als wenn er schon ziemlich froh wäre überhaupt seine Daten in den PC zu bekommen.

Edit:
Du verweist oft auf LIBNODAVE, damit habe ich früher auch gearbeitet, bin aber seit ein paar Jahren davon weg, da zu viele Klimmzüge nötig sind (64-Bit OS, usw.). Schau Dir mal die Kompatibilitätsliste von Snap7 an:

http://snap7.sourceforge.net/compatibility.html

@Alex: Wenn Du mir ein paar Daten zukommen lässt, kann ich Dir ein Demoprogramm zusammenbasteln.

Ich bräuchte:

  • IP-Adresse des CP
  • Baugruppenträger der CPU
  • Steckplatz der CPU
  • Die Datenbausteinnummer aus dem die Daten gelesen werden sollen
  • die Adressen im Datenbaustein die ausgelesen werden sollen (inkl. Typ z.B. Byte, Word, Int, DInt, Real, usw.)

evtl. kannst Du das ganze aber auch schon mal selbst ausprobieren wenn Du den PLCgrabber aus meinem ersten Post herunterlädst

SPS-Analyse-Tool: PLCgrabber

Gruß, Andreas
 
Zuletzt bearbeitet:
Ich danke euch allen für die Hilfe.

@Gerhard Bäurle:
Deine Lösungsvorschläge sind mir komplett neu, diese Variante habe ich noch nie gesehen. Gut zu wissen, dass es so etwas gibt.


Ich denke jedoch, dass ich mit Snap7 oder Libnodave näher an dem bin, was ich möchte.

@Andreas:
Danke für deine Mühe. Ein Demoprogramm wäre sehr schön, es muss auch nicht in VB.NET sein, damit ich es verstehen kann.
Ich habe mir gestern Libnodave und Snap7 heruntergeladen, muss allerdings noch eine "TEST-SPS" aufbauen.
Dein Programm PLCgrabber werde ich bei Gelegenheit auch mal testen, das sieht sehr gut aus - Hut ab!

@Harald:
Wahnsinn, was hier für eine FAQ erstellt wurde.

HW-Konfig und IP-Adresseneinstellungen sind soweit klar.
Prinzipiell gebe ich die Daten über den CP343 aber über AG_SEND aus?
Hat jemand Erfahrungen mit dem CP1543 gemacht bzw. das Ganze schon im TIA umgesetzt?

Ich will für den Test bei Step 7 bleiben, würde mich aber mal interessieren.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@Alex: Wenn Du über Snap7 an die Steuerung gehst, musst Du nichts mit AG_SEND usw. in der Steuerung machen. Vom Prinzip ist es einfach so als wenn Du Dein PG an die Steuerung anschließt, den Simatic Manager öffnest, Dich mit der Station verbindest und über eine Variablentabelle ein paar Werte anzeigen lässt.

ich schiebe gleich nochmal ein Codebeispiel in PureBasic hinterher, das ist für den Zugriff auf PLCsimulate aus dem PLCgrabber Paket ausgelegt. Da die Codemenge so gering ist, müsstest Du das sogar mit der Demo von PureBasic kompiliert kriegen.

Ich könnte Dir auch ein Kompilat anhängen, weiß aber nicht ob ich das an den Post anhängen kann.

Gruß, Andreas
 
Prinzipiell gebe ich die Daten über den CP343 aber über AG_SEND aus?
Hat jemand Erfahrungen mit dem CP1543 gemacht bzw. das Ganze schon im TIA umgesetzt?
Nein, Du brauchst kein AG_SEND/AG_RECV
Bei all den Bibliotheken welche per S7-Protokoll mit der CPU kommunizieren braucht man in der CPU nichts programmieren, weil alle S7-CPU und IE-CP und DP-CP unterstützen das S7-Protokoll als Server schon per Firmware. Variablen können auch im STOP der CPU gelesen und beschrieben werden.

Bei S7-1200 und S7-1500 muß die Kommunikation per S7-Protokoll allerdings erst in der Hardware-Konfig freigeschaltet werden, weil das S7-Protokoll auch sehr destruktiv und virulent genutzt werden kann (man kann so ziemlich alle Speicherbereiche rücksichtslos beschreiben und auch Programmänderungen durchführen - eben alles, was auch ein PG mit Step7 kann). Bei S7-1200 und S7-1500 kommt noch dazu, daß es da "optimierte" Speicherbereiche gibt, welche nur symbolisch angesprochen werden können, was nur wenige Bibliotheken beherrschen).

Harald
 
So, habe mal noch schnell ein paar Kommentare hinzugefügt.

PureBasic Quellcode, der auch mit der Demo funktionieren müsste:

Code:
; =============================================================================
; Programmname:       Snap7-MinimalDemo
; Beschreibung:       Liest zyklisch Daten aus DB1 (PLCsimulate) aus
;
; Erstellt am:        27.11.2016 - 18:25:09
; Autor:              Andreas Schweitzer
; Version:            1.0
; Compiler:           PureBasic 5.50 (Linux - x64)
; Compiler:           PureBasic 5.50 (Windows - x86)
;{=============================================================================
; Compiler-Optionen
;  [ ] InlineASM-Unterstützung einschalten
;  [x] Unicode-Executable erstellen
;  [ ] Thread-sicheres Executable erstellen
;  [ ] OnError-Unterstützung einschalten
;
; Executable-Format:  Linux
; Library Subsystem:
; Datei-Format:       UTF-8
; =============================================================================
; Compiler-Optionen
;  [ ] InlineASM-Unterstützung einschalten
;  [x] Unicode-Executable erstellen
;  [ ] Thread-sicheres Executable erstellen
;  [ ] OnError-Unterstützung einschalten
;  [x] Moderne Themen-Unterstützung aktivieren (für Windows XP und höher)
;  [ ] Administrator-Modus für Windows Vista und höher anfordern
;  [x] User-Modus für Windows Vista und höher anfordern (keine Virtualisierung)
;
; Executable-Format:  Windows
; Library Subsystem:
; Datei-Format:       ASCII
;}=============================================================================

EnableExplicit

; -----------------------------------------------------------------------------
; Hilfsfunktionen
; -----------------------------------------------------------------------------

Structure BLEC
  Byte0.a
  Byte1.a
  Byte2.a
  Byte3.a
EndStructure

Procedure BLEC16(*SWord.BLEC) ; Big-Little-Endian Konverter für 16-Bit Werte

  Swap *SWord\Byte0, *SWord\Byte1

EndProcedure
;==================================================================================================
Procedure BLEC32(*DWord.BLEC) ; Big-Little-Endian Konverter für 32-Bit Werte

  Swap *DWord\Byte0, *DWord\Byte3
  Swap *DWord\Byte1, *DWord\Byte2

EndProcedure
;==================================================================================================

Procedure.i GetBit(*DatenByte, BitNummer.i) ; Prüfen ob das angegebene Bit 1 oder 0 ist

  If Not (BitNummer < 0 Or BitNummer > 7)

    ProcedureReturn PeekA(*DatenByte) >> BitNummer & 1

  EndIf

EndProcedure
;==================================================================================================


; -----------------------------------------------------------------------------
; Einbindung Snap7-Bibliothek (Minimalkonfiguration, DB's lesen)
; -----------------------------------------------------------------------------

Global SNAP7_LIB.i

CompilerSelect #PB_Compiler_OS

  CompilerCase #PB_OS_Windows
  If FileSize(GetPathPart(ProgramFilename()) + "libsnap7.dll") > -1 Or FileSize("libsnap7.dll") > -1
    SNAP7_LIB = OpenLibrary(#PB_Any, GetPathPart(ProgramFilename()) + "libsnap7.dll")
    If Not SNAP7_LIB : SNAP7_LIB = OpenLibrary(#PB_Any, "libsnap7.dll") : EndIf
  EndIf

  CompilerCase #PB_OS_Linux
  If FileSize(GetPathPart(ProgramFilename()) + "/libsnap7.so") > -1 Or FileSize("libsnap7.so") > -1
    SNAP7_LIB = OpenLibrary(#PB_Any, GetPathPart(ProgramFilename()) + "/libsnap7.so")
    If Not SNAP7_LIB : SNAP7_LIB = OpenLibrary(#PB_Any, "libsnap7.so") : EndIf
  EndIf

CompilerEndSelect

If SNAP7_LIB

  ; -----------------------------------------------------------------------------
  ; Snap7 Befehle einbinden (Funktion der Befehle siehe Snap7-Doku)
  ; -----------------------------------------------------------------------------

  #S7AreaDB = $84
  #S7WLByte = $02

  Prototype Cli_Create()
  Global Cli_Create.Cli_Create = GetFunction(SNAP7_LIB, "Cli_Create")

  Prototype Cli_Destroy(*Client)
  Global Cli_Destroy.Cli_Destroy = GetFunction(SNAP7_LIB, "Cli_Destroy")

  Prototype Cli_ConnectTo(Client.i, *Address, Rack.l, Slot.l)
  Global Cli_ConnectTo.Cli_ConnectTo = GetFunction(SNAP7_LIB, "Cli_ConnectTo")

  Prototype Cli_Connect(Client.i)
  Global Cli_Connect.Cli_Connect = GetFunction(SNAP7_LIB, "Cli_Connect")

  Prototype Cli_ReadArea(Client.i, Area.l, DBNumber.l, Start.l, Amount.l, WordLen.l, *pUsrData)
  Global Cli_ReadArea.Cli_ReadArea = GetFunction(SNAP7_LIB, "Cli_ReadArea")

EndIf


; -----------------------------------------------------------------------------
; Hauptprogramm
; -----------------------------------------------------------------------------

Define Event.i
Define Ausgabe$
Define ProgrammName$   = "Snap7-MinimalDemo"
Define Fehler.i        = #True
Define ZyklusZeit.i    = 1000          ; Zeitwert in Millisekunden, nach dem eine Leseoperation durchgeführt wird
Define TempZeit.i      = ElapsedMilliseconds()
Define EditorSchrift.i = LoadFont(#PB_Any, "Courier New", 20, #PB_Font_Bold)

Define Client.i
Define *IpAdresse = Ascii("127.0.0.1") ; IP-Adresse des CP
Define Rack.i     = 0                  ; Baugruppenträger
Define Slot.i     = 2                  ; Steckplatz der CPU
Define *S7_Daten  = AllocateMemory(50) ; Speicherbereich in den die Daten eingelesen werden (50 Byte)

If SNAP7_LIB

  ; -----------------------------------------------------------------------------
  ; Client erstellen und mit Station verbinden
  ; -----------------------------------------------------------------------------

  Client = Cli_Create()

  If Cli_ConnectTo(Client, *IpAdresse, Rack, Slot) = 0

    ; -----------------------------------------------------------------------------
    ; Fenster für Ausgabe öffnen
    ; -----------------------------------------------------------------------------

    If OpenWindow(0, 0, 0, 800, 600, ProgrammName$, #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget)

      EditorGadget(0, 0, 0, WindowWidth(0), WindowHeight(0), #PB_Editor_ReadOnly)
      SetGadgetFont(0, FontID(EditorSchrift))
      SetGadgetColor(0, #PB_Gadget_BackColor, $000000)
      SetGadgetColor(0, #PB_Gadget_FrontColor, $00AA00)

      Fehler = #False

      ; -----------------------------------------------------------------------------
      ; Hauptschleife
      ; -----------------------------------------------------------------------------

      Repeat

        Event = WaitWindowEvent(ZyklusZeit)

        Select Event

          Case #PB_Event_CloseWindow
            Break

          Default

            ; -----------------------------------------------------------------------------
            ; Daten aus S7 Station lesen
            ; -----------------------------------------------------------------------------

            If ElapsedMilliseconds() - TempZeit >= ZyklusZeit
              TempZeit = ElapsedMilliseconds()
              
              If Cli_ReadArea(Client, #S7AreaDB, 1, 0, 50, #S7WLByte, *S7_Daten) = 0 ; der eigentliche Lesebefehl
                
                BLEC32(*S7_Daten + 20) ; Datentypen größer 1 Byte müssen vom Big-Endian ins Little Endian Format konvertiert werden
                BLEC32(*S7_Daten + 24)

                ; -----------------------------------------------------------------------------
                ; Ausgabe-String zusammenstellen und im Fenster anzeigen
                ; -----------------------------------------------------------------------------

                Ausgabe$ = "Steuerung Ein      " + Str(GetBit(*S7_Daten, 0)) + #CRLF$
                Ausgabe$ + "Störung Quittieren " + Str(GetBit(*S7_Daten, 1)) + #CRLF$
                Ausgabe$ + "Automatik          " + Str(GetBit(*S7_Daten, 2)) + #CRLF$
                Ausgabe$ + "Start              " + Str(GetBit(*S7_Daten, 3)) + #CRLF$
                Ausgabe$ + "Stopp              " + Str(GetBit(*S7_Daten, 4)) + #CRLF$
                Ausgabe$ + "Reset Stückzähler  " + Str(GetBit(*S7_Daten, 5)) + #CRLF$
                Ausgabe$ + "Steuerung Ein      " + Str(GetBit(*S7_Daten + 2, 0)) + #CRLF$
                Ausgabe$ + "Störung            " + Str(GetBit(*S7_Daten + 2, 1)) + #CRLF$
                Ausgabe$ + "Einzelhub          " + Str(GetBit(*S7_Daten + 2, 2)) + #CRLF$
                Ausgabe$ + "Automatik          " + Str(GetBit(*S7_Daten + 2, 3)) + #CRLF$
                Ausgabe$ + "Stückzahl erreicht " + Str(GetBit(*S7_Daten + 2, 5)) + #CRLF$
                Ausgabe$ + "Hub Aktiv          " + Str(GetBit(*S7_Daten + 2, 6)) + #CRLF$
                Ausgabe$ + "Materialvorschub   " + Str(GetBit(*S7_Daten + 2, 7)) + #CRLF$
                Ausgabe$ + "Stößelweg:         " + StrF(PeekF(*S7_Daten + 20), 2) + #CRLF$
                Ausgabe$ + "Presskraft:        " + StrF(PeekF(*S7_Daten + 24), 2) + #CRLF$
                SetGadgetText(0, Ausgabe$)
              Else

                ; -----------------------------------------------------------------------------
                ; Wenn Verbindung unterbrochen wurde (z.B. Kabel), versuchen neu zu verbinden
                ; -----------------------------------------------------------------------------

                If Cli_Connect(Client) = 0
                  SetWindowTitle(0, ProgrammName$)
                Else
                  SetWindowTitle(0, ProgrammName$ + " - Verbindung unterbrochen")
                EndIf
              EndIf
            EndIf

        EndSelect

      ForEver

    EndIf

  EndIf

  Cli_Destroy(@Client) ; Client sauber aus dem Speicher entfernen

  CloseLibrary(SNAP7_LIB) ; Snap7-Bibliothek schließen

EndIf

; Reservierte Speicherbereiche wieder freigeben
FreeMemory(*IpAdresse)
FreeMemory(*S7_Daten)

; -----------------------------------------------------------------------------
; Wenn keine Verbindung möglich -> Fehler ausgeben
; -----------------------------------------------------------------------------

If Fehler
  MessageRequester("Fehler", "Fehler bei Verbindung aufgetreten," + #CRLF$ + "Das Programm wird beendet.", #PB_MessageRequester_Error)
EndIf

End
;

und fertig kompiliert im Anhang

Anhang anzeigen Snap7-MinimalDemo.zip

Bitte darauf achten, dass das Programm nach "libsnap7.dll" und nicht nach "Snap7.dll" (unter diesem Namen ist sie im Snap7-Paket) sucht. Evtl. umbenennen oder die libsnap7.dll aus dem PLCgrabber Paket verwenden.

Gruß, Andreas
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Danke für die Mühe, PureBasic ist für mich persönlich momentan schwerer zu verstehen, aber Ablauf etc. ist mir jetzt klar.

Eine Frage hätte ich noch, muss leider noch bis morgen auf mein Test CP warten. Spielt es eine Rolle, ob man den Profinet CP343 oder den Industrial Ethernet CP343 nimmt? Im Beispiel von Snap7 wird alles mit Profinet gemacht, ich dachte aber an IE
 
Ich habe mein Versuchsmodell aufgebaut und losgelegt, die Verbindung steht!
Jetzt geht es an die Arbeit, ich habe momentan nur noch Probleme den Empfangspuffer auszuwerten. Alles kommt Hexadezimal und muss quasi noch in die gewünschten Datenformate umgewandelt werden.

Ich werde mich gleich dran machen und das ein oder andere testen oder gibt es da vielleicht auch Codebeispiele? Ansonsten würde ich über System.Convert alles umwandeln.
 
Zurück
Oben