TIA Tia DB indierekter Zugriff auf Datenwort

SPS Jogi

Level-2
Beiträge
11
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo ich komme aus der S5 / Step7 klassik Welt und versuche nun auf ein Datenwot im nicht optimierten DB zuzugreifen und stopler über die Syntax.
Siehe Bild
DB.png
Wie ist die symbolische Schreibweise um auf z.b. Offset 0 zuzugreifen.

Ich habe es versucht mit" "DB Servo"."[Zeiger]". was mache ich falsch? Die Struktur ist mir dabei egal.
Das ganze findet in einer 1200er CPU statt, also alles in FUP mit dem Move Block
Wer hat eine Idee?

Vielen Dank im Vorraus
 
Der Symbolische zugriff sieht doch so aus
irgendwas := "DB SERVO".Position."Target Pos" ;

man sollte davon Abstandnehmen leer Zeichen in die Variablen Namen einzufügen.
TargetPos tuts doch auch.

und ein Tip wenn dir die Syntax nicht klar ist öffne eine Beobachtungstabelle und zieh
einfach das Target Pos darein . TIA füllt den Rest dann schon aus
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo und Danke für die guten Tipps
die Lösung ist die von Hucki
per PEKE/POKE.
Als "die Lösung" würde ich es nicht gerade betiteln.
Ist halt was kompatbles zu dem alten Kram.

Dabei wäre eine neue Hardware auch ein guter Zeitpunkt auf aktuelle Vorgehensweisen upzudaten.
;)
 
Ich klinke mich hier mal ein.

Wir haben eine Kundenanlage auf TIA umgestellt, dort ist ein DB vorhanden, der lauter Bools enthält, die alles Bitmeldungen der SPS darstellen.
Diese wurden bisher mit einem AWL-Netzwerk als DWORD "ausgelesen" und geschaut, ob das DWord ungleich null ist - sprich: Meldung aktiv.

Das Panel hat dann per Adresse auf den DB zugegriffen, die Bools als DWORD interpretiert und so nur 1 Tag genutzt, um 32 Bitmeldungen über die HMI Schnittstelle schieben zu können.

Ich habe dann das System auf eine 1200er portiert, lief auch einwandfrei. Dazu habe ich den Serialize Befehl genommen. Problem ist, dass auf manchen alten Steuerungen der Befehl nicht unterstützt wird (bspw. eine ET200-1500er CPU). Also habe ich das ganze auf PEEK/POKE umgestellt. Dazu muss ich dem Baustein allerdings die Nummer de DBs übergeben.

Konkrete Fragen:
Geht das mit optimierten DBs (ohne PEEK / POKE)?
Geht das eleganter, ohne die DB Nummer oder DB Größe zu kennen?

Hier noch der Code, den ich nutze (die Adresse muss um 2 erhöht werden, weil noch die Stationsnummer am Anfang des DBs steht):

Code:
FUNCTION "DWORD_WinCC_Conversion" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      i_n_BoolDB : UInt;   // number of source DB of bool which needs to be converted to DWORD
      i_n_DWordDB : UInt;   // number of target DB of Dword
      i_n_Dwords : UInt;   // number of DWORDS which need to be converted
   END_VAR


   VAR_TEMP 
      i : Int;   // Runner
      tempDword : DWord;
      tempSwapDword : DWord;
      returnWord : Word;
   END_VAR




BEGIN
    FOR #i :=0 TO UINT_TO_INT(#i_n_Dwords-1) DO
        #tempDword := PEEK_DWORD(area       := 16#84,
                                 byteOffset := #i*4+2,
                                 dbNumber   :=#i_n_BoolDB);
        
       #tempSwapDword  := SWAP_DWORD(#tempDword);
        
        POKE(area:= 16#84,
             dbNumber:=#i_n_DWordDB,
             byteOffset:=#i*4,
             value:=#tempSwapDword
        );
        
    END_FOR;
END_FUNCTION

Viele Grüße und vielen Dank!
 
Du kannst auch die Bitmeldungen als DWORD oder WORD deklarieren (passt dann für den <> 0 Vergleich und zum HMI) und auf die Bits selber direkt per Slice zugreifen:
Code:
MeldeWord_1.%X1 := #Meldung;
LeuchteRot_Maschine1 := (MeldeWord_1 <> 0) OR MeldeWord_2.%X13;
...
PEEK/POKE braucht man eigentlich nur wenn man indirekt adressiert auf Adressen zugreifen will.

Weitere Lösungen: Mit BOOL-Array arbeiten, und/oder die Bits per GATHER zu DWORDS zusammenfassen, oder klassisch maskieren.

Harald
 
Du kannst auch die Bitmeldungen als DWORD oder WORD deklarieren (passt dann für den <> 0 Vergleich und zum HMI) und auf die Bits selber direkt per Slice zugreifen:
Code:
MeldeWord_1.%X1 := #Meldung;
LeuchteRot_Maschine1 := (MeldeWord_1 <> 0) OR MeldeWord_2.%X13;
...
PEEK/POKE braucht man eigentlich nur wenn man indirekt adressiert auf Adressen zugreifen will.

Weitere Lösungen: Mit BOOL-Array arbeiten, und/oder die Bits per GATHER zu DWORDS zusammenfassen, oder klassisch maskieren.

Harald

Hallo Harald,

danke für deine Antwort. Prinzipiell können wir das so machen, aber wir generieren die Meldungen leider anders.

Ich beschreibe vielleicht erst einmal den Ist-Stand:

Es gibt eine Master Excel-Liste, in der alle Störungen als eigene Zeile aufgeführt sind. Die Excel hat dann noch weitere Tabellenblätter, das zweite Tabellenblatt ist die Quelle für den TIA-DB, das dritte Tabellenblatt war bisher die DWORD-Adresse der Bits für die TAG Tabelle in WinCC und das nächste Tabellenblatt konnte per copy & paste in die Meldeverwaltung in WinCC eingefügt werden. Weitere Tabellen haben die Meldetextsprachen, Meldeklassen etc. pp. geregelt.

In Bildern:

Die Exceltabelle, in der alles konfiguriert wird, inkl. Übersetzungen:
excel.jpg

Der daraus entstehende DB:
db_faults.jpg

Die Verknüpfung des DWORDS-Zugriffs auf den Bool-DB:
dword_tags.jpg

Die Meldungen selbst zum kopieren nach WinCC (inkl. Byte-Swap):
dword_bitlink.jpg


Und anschließend noch einmal die Frage nach dem, was auch Larry schon schreibt:
Wir wollen ja Weg vom adressbasiertem System. Weiterhin aber an den Einzelnen Bits für die einzelnen Störmeldungen festhalten. Die Frage war jetzt, ob es eine Funktion gibt, die sinngemäß folgendes macht:

Ich habe einen Eingang (Zeiger, Variant, Referenz, hier bin ich relativ unerfahren in den Datentypen), einmal auf den Quell-DB, einmal einen InOut / Out - Zeiger auf den Ziel DB (der von mir aus wesentlich größer sein kann, um universell einsetzbar zu sein).

Ich möchte jetzt per SCL (oder FUP/KOP, wenn es sein muss) quasi abfragen: Hole mir aus dem Anfang des Zeigerbereichs die ersten 32 Bits und packe die in ein DWORD, führe einen SWAP durch und speichere diese in dem ersten DWORD des Ziel DBs.
Mache das so lange, bis du am Ende des Zeigereingangbereichs angekommen bist und fülle den Rest (falls Quell DB nicht komplett auf 32 Bit auffüllt) mit Konstanten Nullen auf.

Dazu bin ich nicht in der Lage, weil meine Programmierfähigkeiten an der Syntax von TIA Portal scheitern. Denn es ist genau das, was ihr schreibt: Ich möchte weg von dem Adressbasiertem und hinzu einer symbolischen Programmierung.
Der einzige Weg, wie ich dies bisher hinbekommen habe, ist über PEEK/POKE und absolutem Zugriff auf die Bereiche.

Falls es andere Alternativen gibt, bin ich natürlich nicht beratungsresistent - es ist nur schwer in dem Industriezweig etwas komplett neues zu etablieren und vor allem zu validieren / zertifizieren.

Vielen Dank für eure Mühe,

Andreas
 
Die TIA Variante dafür ist, zu schreibst dir eine Funktion mit 32 Eingängen und einem DWORD als Ausgang, und beschaltest dann alle 32 Eingänge symbolisch mit der Variable aus dem Störungs-DB.
Das ist zwar etwas Tipparbeit bei 78 Wörtern oder du machst dir schnell ein Excel Makro welches aus dem DB die Aufrufe erzeugt, aber dann ist alles symbolisch nachvollziehbar und du hast auch zu jedem Störbit ein Querverweis an welcher Stelle das in das DWORD geschrieben wird.

Ich würde mir mal überlegen, ob nicht an der Stelle an der die Störbits erzeugt werden, nicht auch gleich das Melde DWORD erzeugt werden kann. Anstatt da anschließend nochmal drüberzugehen, und womöglich auch noch mit Sammelstörungsbits einsammeln.
 
Ich würde mir mal überlegen, ob nicht an der Stelle an der die Störbits erzeugt werden, nicht auch gleich das Melde DWORD erzeugt werden kann. Anstatt da anschließend nochmal drüberzugehen, und womöglich auch noch mit Sammelstörungsbits einsammeln.
Diese Idee finde ich persönlich übrigens auch wesentlich eleganter - etwas Ähnliches hatte ich früher auch so schon mal gemacht ...
 
Hallo zusammen,

danke für eure Hilfe. Ich möchte das auch nicht ausarten lassen, weil ja schon eine Lösung "existiert". Aber mir geht es genau wie Larry, weil ich mir denke: Da muss es doch was schöneres geben.

Anforderung:
  • DB mit Bitmeldungen nach DWORD schaufeln
    • Hintergrund: Powertags in WinCC sparen
  • Vorgabe vom Ersteller WinCC 7.5 SCADA System:
    • 'Wir entwickeln einen neuen Softwarestandard, da machen wir das ganze nach "Stand der Technik", d.h. symbolisch und nicht über Adressen' - sinngemäß sein O-Ton
  • Vorgabe in der SPS:
    • Es muss eine Sammelstörungsauswertung für den Bool-DB möglich sein. Daher die Idee, bei der Wandlung von BOOLs in DWORD immer das DWORD auf <> 0 abzufragen und somit eine Sammelstörung genieren zu können

Thomas hat ( / du hast) natürlich recht, man kann das ganze auch in Excel weiterverarbeiten, das muss ich dann aber irgendwo abstriche machen. Weiterhin stört mich eins an der Lösung: Ich finde sie technisch nicht elegant. Wenn ich dich / euch richtig verstanden mache, dann füge ich bei Excel noch die Umwaldung (entweder über einen FC der BOOLS => DWORD schaufelt oder eine Direktzuweisung) mit ein, das sähe dann bspw. wie folgt aus:

Code:
#S1_faultDWord001.%X8 :=  S1_DB_faults.ST1000_general_software;
#S1_faultDWord001.%X9 :=  S1_DB_faults.ST1001_general_hardware;
#S1_faultDWord001.%X26 :=  S1_DB_faults.ST1002_general_;
#S1_faultDWord001.%X27 :=  S1_DB_faults.ST1003_general_;
#S1_faultDWord001.%X28 :=  S1_DB_faults.ST1004_general_;
#S1_faultDWord001.%X29 :=  S1_DB_faults.ST1005_general_;
#S1_faultDWord001.%X30 :=  S1_DB_faults.ST1006_general_;
#S1_faultDWord001.%X31 :=  S1_DB_faults.ST1007_general_;
#S1_faultDWord001.%X16 :=  S1_DB_faults.ST1008_general_;
#S1_faultDWord001.%X17 :=  S1_DB_faults.ST1009_general_;
#S1_faultDWord001.%X18 :=  S1_DB_faults.ST1010_general_;
#S1_faultDWord001.%X19 :=  S1_DB_faults.ST1011_general_;
#S1_faultDWord001.%X20 :=  S1_DB_faults.ST1012_general_;
#S1_faultDWord001.%X21 :=  S1_DB_faults.ST1013_general_;
#S1_faultDWord001.%X22 :=  S1_DB_faults.ST1014_general_;
#S1_faultDWord001.%X23 :=  S1_DB_faults.ST1015_general_;
#S1_faultDWord002.%X24 :=  S1_DB_faults.ST1016_general_24Vng;
#S1_faultDWord002.%X25 :=  S1_DB_faults.ST1017_general_mainVOltageNG;
#S1_faultDWord002.%X26 :=  S1_DB_faults.ST1018_general_USPlow;
#S1_faultDWord002.%X27 :=  S1_DB_faults.ST1019_general_overVoltage;

Das habe ich jetzt einfach mal in Excel als Zeile hinzugefügt. Das könnte ich in ein SCL Netzwerk mit hineinpacken. Alternativ müsste ich beim Programmieren der Software immer an der Stelle, wo auch das Bit geschrieben wird, per Slice das Bit im DWORD setzen - was aber auch sehr umständlich ist und zu sehr viel Mehraufwand führt. Beispiel:

2020-12-22 15_48_12-Window.jpg

Meine eigentlich Frage: Wie schaffe ich das, mit aktuellen TIA-Bordmitteln ( TIA >= 15.1) "schön" zu programmieren, dass ich einen X-beliebigen Bool-Struct / DB / Variant / irgendwas in einen Y-beliebigen DWORD-Struct / DB / Variant irgendwas zu wandeln.
Dabei Gilt zu prüfen, ob der Bereich des Ziels groß genug ist, ob die Quelle aufgefüllt oder abgeschnitten werden soll o.ä.

Mit Arrays könnte man das über bspw. Upper / Lower Bounds prüfen. Gibt es keine Funktionen in TIA Portal, die die Bearbeitung von Zeigern zulassen und dann "halbdynamisch" (da eine SPS nicht vollständig dynamisch agieren kann, was ihren Speicher angeht) das Problem zu lösen?

Wirklich sehr sehr Pseudemäßig:

Code:
IF FRAC(#EndeDesSpeicherbereichsDesEingangszeigers; 4) = 0.0 THEN
 // Wunderbar, wir können genau DWORDS füllen
ELSE
 // Uih, wir müssen was auffüllen und das Ende anpassen
END_IF;

#sammelmeldung  := false;
FOR #i := 0 to #EndeDesSpeicherbereichsDesEingangszeigers / 4 DO
 #AusgangswortZeigerBereich[#i] := SWAP(#EingangszeigerAlsDWortInterpretiert[#i]);
IF #AusgangswortZeigerBereich[#i] <> 0 THEN
 #sammelmeldung  := true;
END_IF;
END_FOR:

Sorry für das kryptische... ich hoffe, ihr könnt verstehen, was ich meine...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Du versuchst mit aller Gewalt über unstrukturierte Daten eine Struktur zu legen, anstatt die Daten gleich strukturiert anzulegen.

Also ich kann nur für meinen Anwendungsbereich sprechen. Ich versuche fast alles mit Objekten zu erledigen, Motoren, Ventile, Messungen, und auch Meldeobjekte um einfach 8 oder 16 Bitmeldungen zu verarbeiten. Wenn ich bei WinCC bleibe, dann habe ich 1 oder 2 Status-DWORDs in dem diverse Statusanzeigen dargestellt werden, unter anderem auch die Triggerbits für das Alarmlogging. Da hast du zwar ggf. ein paar Reserven, dafür ist es aber strukturiert. Und ich muss auch nicht anschließend irgendwelche Sammelstörmeldungen einsammeln, weil das meine Objekte schon machen.

Das passt vermutlich nicht für alle Anwendungsbereiche, und auch das hat ein paar Nachteile. Ich fahre damit aber auch unter TIA einigermaßen gut, sodass ich bei der 1200/1500 von Peek und Poke bisher (bis auf eine Ausnahme zur Datensicherung) Abstand halten konnte.
 
Ich versuche mit aller Gewalt meine Form von strukturierten Daten irgendwie in der TIA Welt zu verarbeiten. So sehe ich das.

Die Störmeldeliste ist im Rahmen einer GAMP 5 Validierung eines Prozesssystems ein eineindeutige Zuordnung in einem Dokument, dass erstellt, geprüft, programmiert, freigegeben und validiert wird. Komponenten werden bei uns nach Komponentenprüflisten nach Funktionen geprüft, Störmeldungen gibt es aber nicht nur bezogen auf Komponenten, wie Motoren, Ventile, etc. pp. sondern auch bezogen auf die Gesamtanlage und den Prozess selbst. D.h. die Störmeldungen werden zentral gesammelt.

Daran kann ich nichts ändern. Wenn wir diese Daten nun Strukturieren würden, kämen diverse Möglichkeiten in Betracht, bspw. diese in ein Array zu packen. Dann kann ich aber nicht mehr mit symbolischen Namen je Störmeldung arbeiten, sondern muss mit Indices arbeiten - gut, die könnte ich über Konstanten definieren, fällt mir gerade ein. Aber wie sieht es bspw. mit den Kommentaren bei einzelnen Bits in einem Bool-Array aus? Kann ich die einzeln bearbeiten und werden die angezeigt, wenn ich mit Konstanten darauf zugreife?

Unabhängig davon, ob jetzt meine Störmeldungen unstrukturiert angelegt sind oder nicht, ob und was Sinn macht oder nicht, vollkommen egal. Wenn ich mich nur auf die Fragestellung reduziere, ob es eine Möglichkeit gibt auf einen irgendwie übergebenen Speicherbereich zuzugreifen, diese nach Größe in Bit / Byte / Wort / ... zu interpretieren und dann in einen anderen zu übergeben, inkl. Prüfmechanismen, ob irgendwelche Speicherbereichsgrenzen verletzt werden, dann heißt es also: Nein - das geht in TIA nicht (?). Nur, wenn ich konkret einzelne Datentypen übergebe?

Ich möchte mich ja in die einzelnen speziellen Datentypen einarbeiten, dazu benötige ich ja keine komplett vorgeschrieben Lösung, aber zumindest ein paar Brotkrumen wären nett. Aus o.g. Anlass werde ich nicht anfangen, die Bool-DB-Störmeldungsstruktur über den Haufen zu werfen - weil ich es auch einfach nicht kann. Sollte es hier ein besseres System geben, lasse ich mich gerne inspirieren, dem Kunden etwas anderes vorzuschlagen.

Sorry für das lange ausholen, aber im Grunde möchte ich "nur" wissen, ob man auf einen blöden Eingangszeiger irgendwie definiert reagieren kann.
 
Hallo ADS,

ich finde, daß sich die Vorschläge und Dein Vorhaben nicht unbedingt ausschließen. Gerade heute in Zeiten von "großen" Speichern...

Ich nutze gerne eine Kombination und auch bei Kunden habe ich das schon häuffig gesehen:

Man erstellt Objekte, so weit es geht. Hierbei muß ich mich ja nicht auf einen Motor, ein Ventil, eine Pumpe beschränken, sondern ich kann auch weiter ausholen:
Schaltschrank, Fertigungsstraße, ..., Anlage, ... und mit diesen "übergeordneten" Objekten sammel ich dann die Signale ein, die ich keinem "kleinen" Objekt zuordnen kann. Z.B. Sicherungsfall von Hauptsicherungen, Verfügbarkeiten von Spannungen, Schaltschranktemperaturen, Not-Aus-Taster, ....

Dann habe ich, wie Thomas, alles in Objekte verpackt. Jedes Objekt hat z.B. ein DWORD als Fehler-/Status.
Jetzt habe ich zwei Möglichkeiten:
Entweder ich gebe im Meldesystem nur noch Sammelmeldungen aus (das macht z.B. ein Kunde auf Schiffen und das ist auch vom DNVGL abgenickt) und die Details finde ich dann im Objekt-Dialog.

Oder ich übergebe dieses DWORD dann an die Visu. Oder meinetwegen auch - da nutze ich dann auch gerne Excel - als Ganzes oder einzelne Bits an einen Baustein, der mir das dann als Bitmeldungen in einen Störmelde-DB schreibt. Dieser ist dann natürlich recht anonym. Aber wenn man die Daten strukturiert dort übergibt, dann findet man über den Übergabebaustein wieder die Zuordnung.

Um einzelne Bitmeldungen strukturiert zu übergeben an ein DWORD, eigent sich ein Baustein, wie oben schon beschrieben. Vor allem kommt man bei einem Baustein später nicht mehr durcheinander bei der Wort- und Bytedrehung.

Außerdem mag ein Auditor immer klar strukturierten Code - und gerne grafischen Code, da muß er nicht denken. Also würde ich so einen Zuordnungs-Baustein in FUP aufrufen, alle Meldungen dranprojektieren und hinten fällt ein fertiges DWORD raus, das im DB abgelegt wird. Wenn ich 20 DWORDs habe, habe ich einen Strömeldebaustein mit 20 Netzwerken. Das blickt der dümmste Auditor.

Im Baustein selber kann man ja die verschiedensten Verfahren anwenden, um die Bits in das DWord zu bekommen.

Aber noch einfacher ist eben die Objekt-Variante. Ich habe 100 Objekte, also 100 DWORDs. Jedes Objekt bekommt sein DWORD zugeordnet, fertig.
Das charmante an Objekten ist dann auch - ich kenne ja Deine Anlage nicht -, daß man ggf. Codevorlagen machen kann und sich Programme generieren kann, wenn man ähnliche Anlagen öfter erstellt.

Gruß
Jens
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Sag doch deinem WinCC Projektierer, er soll eine größere Variablenlizenz kaufen und die Bitmeldungen alle einzeln anlegen. Dann ist alles symbolisch und es muss nichts umkopiert werden, keiner muss nachsehen wo in welchem Bit des DWords denn jetzt was abgelegt ist und wo evtl. Bytes gedreht sind. Es gibt Visualisierungen da geht das mit dieser Tag-Sparerei wie bei WinCC auch überhaupt nicht.
 
Ich würde tatsächlich jedem Objekt sein DWORD spendieren. Dann hat man eine Struktur: Gleiche Objekte haben gleiche Störmeldungen. Ich programmiere symbolisch, kann jedem DWord seinen Namen geben. Das läßt sich gut auditieren.

Andererseits brauche ich pro Objekt nur ein Powertag und kann mir Lizenzgebühren sparen.
 
Danke euch beiden! Ich habe mal geschaut, das Upgrade von den 8k auf die 65k Powertags kostet <2k€. Bei der Gesamtanlagensumme sollte das definitiv zu verschmerzen sein, die Bitbeziehung ist ja bereits über das Excel-Sheet gemacht, das könnte man auch direkt in WinCC so angeben. Damit wäre die Beziehung weiterhin eineindeutig und es muss definitiv nichts "umgeschaufelt" werden. Zusätzlich ist es wesentlich Auditor-stringenter.

Wenn man den Gegenwert des Aufwands berechnet, den PL, int. Prüfer, ext. Prüfer / Auditor haben, dann hat man das "schnell" heruntergeschraubt.

Für das "Umschaufeln" habe ich ja schon eine "Lösung" mit peek / poke. Aber nochmal vorsichtig gefragt, auch um das Thema wieder zum eigentlich Sinn zurückzuführen: Gibt es da eine andere Möglichkeit?
 
Zurück
Oben